monitor.c 87.1 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 26 27 28 29 30 31 32 33
#include "hw/hw.h"
#include "hw/usb.h"
#include "hw/pcmcia.h"
#include "hw/pc.h"
#include "hw/pci.h"
#include "gdbstub.h"
#include "net.h"
#include "qemu-char.h"
#include "sysemu.h"
A
aliguori 已提交
34 35
#include "monitor.h"
#include "readline.h"
P
pbrook 已提交
36 37 38
#include "console.h"
#include "block.h"
#include "audio/audio.h"
39
#include "disas.h"
A
aliguori 已提交
40
#include "balloon.h"
41
#include "qemu-timer.h"
A
aliguori 已提交
42
#include "migration.h"
A
aliguori 已提交
43
#include "kvm.h"
44
#include "acl.h"
T
ths 已提交
45

B
bellard 已提交
46
//#define DEBUG
B
bellard 已提交
47
//#define DEBUG_COMPLETION
B
bellard 已提交
48

49 50
/*
 * Supported types:
51
 *
52
 * 'F'          filename
B
bellard 已提交
53
 * 'B'          block device name
54
 * 's'          string (accept optional quote)
B
bellard 已提交
55 56
 * 'i'          32 bit integer
 * 'l'          target long (32 or 64 bit)
57 58 59 60 61 62
 * '/'          optional gdb-like print format (like "/10x")
 *
 * '?'          optional type (for 'F', 's' and 'i')
 *
 */

A
aliguori 已提交
63
typedef struct mon_cmd_t {
B
bellard 已提交
64
    const char *name;
65
    const char *args_type;
66
    void *handler;
B
bellard 已提交
67 68
    const char *params;
    const char *help;
A
aliguori 已提交
69
} mon_cmd_t;
B
bellard 已提交
70

71 72
struct Monitor {
    CharDriverState *chr;
73 74 75 76 77 78 79 80
    int flags;
    int suspend_cnt;
    uint8_t outbuf[1024];
    int outbuf_index;
    ReadLineState *rs;
    CPUState *mon_cpu;
    BlockDriverCompletionFunc *password_completion_cb;
    void *password_opaque;
81 82 83 84
    LIST_ENTRY(Monitor) entry;
};

static LIST_HEAD(mon_list, Monitor) mon_list;
85

A
aliguori 已提交
86 87
static const mon_cmd_t mon_cmds[];
static const mon_cmd_t info_cmds[];
B
bellard 已提交
88

89
Monitor *cur_mon = NULL;
A
aliguori 已提交
90

91 92
static void monitor_command_cb(Monitor *mon, const char *cmdline,
                               void *opaque);
93

94 95 96 97 98 99
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 已提交
100

101 102
static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
                                 void *opaque)
103
{
104 105 106 107 108 109 110 111
    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;
    }
112 113
}

A
aliguori 已提交
114
void monitor_flush(Monitor *mon)
115
{
116 117 118
    if (mon && mon->outbuf_index != 0 && mon->chr->focus == 0) {
        qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
        mon->outbuf_index = 0;
119 120 121 122
    }
}

/* flush at every end of line or if the buffer is full */
A
aliguori 已提交
123
static void monitor_puts(Monitor *mon, const char *str)
124
{
T
ths 已提交
125
    char c;
126 127 128 129

    if (!mon)
        return;

130 131 132 133
    for(;;) {
        c = *str++;
        if (c == '\0')
            break;
B
bellard 已提交
134
        if (c == '\n')
135 136 137 138
            mon->outbuf[mon->outbuf_index++] = '\r';
        mon->outbuf[mon->outbuf_index++] = c;
        if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
            || c == '\n')
A
aliguori 已提交
139
            monitor_flush(mon);
140 141 142
    }
}

A
aliguori 已提交
143
void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
B
bellard 已提交
144
{
B
bellard 已提交
145 146
    char buf[4096];
    vsnprintf(buf, sizeof(buf), fmt, ap);
A
aliguori 已提交
147
    monitor_puts(mon, buf);
B
bellard 已提交
148 149
}

A
aliguori 已提交
150
void monitor_printf(Monitor *mon, const char *fmt, ...)
B
bellard 已提交
151
{
152 153
    va_list ap;
    va_start(ap, fmt);
A
aliguori 已提交
154
    monitor_vprintf(mon, fmt, ap);
155
    va_end(ap);
B
bellard 已提交
156 157
}

A
aliguori 已提交
158
void monitor_print_filename(Monitor *mon, const char *filename)
159 160 161 162
{
    int i;

    for (i = 0; filename[i]; i++) {
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
        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;
        }
182 183 184
    }
}

B
bellard 已提交
185 186 187 188
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
A
aliguori 已提交
189
    monitor_vprintf((Monitor *)stream, fmt, ap);
B
bellard 已提交
190 191 192 193
    va_end(ap);
    return 0;
}

B
bellard 已提交
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
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 已提交
214 215
static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
                          const char *prefix, const char *name)
B
bellard 已提交
216
{
A
aliguori 已提交
217
    const mon_cmd_t *cmd;
B
bellard 已提交
218 219 220

    for(cmd = cmds; cmd->name != NULL; cmd++) {
        if (!name || !strcmp(name, cmd->name))
A
aliguori 已提交
221 222
            monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
                           cmd->params, cmd->help);
B
bellard 已提交
223 224 225
    }
}

A
aliguori 已提交
226
static void help_cmd(Monitor *mon, const char *name)
B
bellard 已提交
227 228
{
    if (name && !strcmp(name, "info")) {
A
aliguori 已提交
229
        help_cmd_dump(mon, info_cmds, "info ", NULL);
B
bellard 已提交
230
    } else {
A
aliguori 已提交
231
        help_cmd_dump(mon, mon_cmds, "", name);
232
        if (name && !strcmp(name, "log")) {
B
blueswir1 已提交
233
            const CPULogItem *item;
A
aliguori 已提交
234 235
            monitor_printf(mon, "Log items (comma separated):\n");
            monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
236
            for(item = cpu_log_items; item->mask != 0; item++) {
A
aliguori 已提交
237
                monitor_printf(mon, "%-10s %s\n", item->name, item->help);
238 239
            }
        }
B
bellard 已提交
240 241 242
    }
}

A
aliguori 已提交
243
static void do_commit(Monitor *mon, const char *device)
B
bellard 已提交
244
{
B
bellard 已提交
245
    int i, all_devices;
246

B
bellard 已提交
247
    all_devices = !strcmp(device, "all");
T
ths 已提交
248
    for (i = 0; i < nb_drives; i++) {
249
            if (all_devices ||
T
ths 已提交
250 251
                !strcmp(bdrv_get_device_name(drives_table[i].bdrv), device))
                bdrv_commit(drives_table[i].bdrv);
B
bellard 已提交
252 253 254
    }
}

A
aliguori 已提交
255
static void do_info(Monitor *mon, const char *item)
B
bellard 已提交
256
{
A
aliguori 已提交
257 258
    const mon_cmd_t *cmd;
    void (*handler)(Monitor *);
B
bellard 已提交
259

260
    if (!item)
B
bellard 已提交
261 262
        goto help;
    for(cmd = info_cmds; cmd->name != NULL; cmd++) {
263
        if (compare_cmd(item, cmd->name))
B
bellard 已提交
264 265 266
            goto found;
    }
 help:
A
aliguori 已提交
267
    help_cmd(mon, "info");
B
bellard 已提交
268 269
    return;
 found:
270
    handler = cmd->handler;
A
aliguori 已提交
271
    handler(mon);
B
bellard 已提交
272 273
}

A
aliguori 已提交
274
static void do_info_version(Monitor *mon)
B
bellard 已提交
275
{
P
pbrook 已提交
276
    monitor_printf(mon, "%s\n", QEMU_VERSION QEMU_PKGVERSION);
B
bellard 已提交
277 278
}

A
aliguori 已提交
279
static void do_info_name(Monitor *mon)
T
ths 已提交
280 281
{
    if (qemu_name)
A
aliguori 已提交
282
        monitor_printf(mon, "%s\n", qemu_name);
T
ths 已提交
283 284
}

A
aurel32 已提交
285
#if defined(TARGET_I386)
A
aliguori 已提交
286
static void do_info_hpet(Monitor *mon)
A
aliguori 已提交
287
{
A
aliguori 已提交
288 289
    monitor_printf(mon, "HPET is %s by QEMU\n",
                   (no_hpet) ? "disabled" : "enabled");
A
aliguori 已提交
290
}
A
aurel32 已提交
291
#endif
A
aliguori 已提交
292

A
aliguori 已提交
293
static void do_info_uuid(Monitor *mon)
294
{
A
aliguori 已提交
295 296 297 298 299
    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]);
300 301
}

B
bellard 已提交
302
/* get the current CPU defined by the user */
303
static int mon_set_cpu(int cpu_index)
B
bellard 已提交
304 305 306 307 308
{
    CPUState *env;

    for(env = first_cpu; env != NULL; env = env->next_cpu) {
        if (env->cpu_index == cpu_index) {
309
            cur_mon->mon_cpu = env;
B
bellard 已提交
310 311 312 313 314 315
            return 0;
        }
    }
    return -1;
}

316
static CPUState *mon_get_cpu(void)
B
bellard 已提交
317
{
318
    if (!cur_mon->mon_cpu) {
B
bellard 已提交
319 320
        mon_set_cpu(0);
    }
321
    cpu_synchronize_state(cur_mon->mon_cpu, 0);
322
    return cur_mon->mon_cpu;
B
bellard 已提交
323 324
}

A
aliguori 已提交
325
static void do_info_registers(Monitor *mon)
326
{
B
bellard 已提交
327 328 329 330
    CPUState *env;
    env = mon_get_cpu();
    if (!env)
        return;
331
#ifdef TARGET_I386
A
aliguori 已提交
332
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
B
bellard 已提交
333
                   X86_DUMP_FPU);
334
#else
A
aliguori 已提交
335
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
B
bellard 已提交
336
                   0);
337 338 339
#endif
}

A
aliguori 已提交
340
static void do_info_cpus(Monitor *mon)
B
bellard 已提交
341 342 343 344 345 346 347
{
    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) {
348
        cpu_synchronize_state(env, 0);
A
aliguori 已提交
349
        monitor_printf(mon, "%c CPU #%d:",
350
                       (env == mon->mon_cpu) ? '*' : ' ',
A
aliguori 已提交
351
                       env->cpu_index);
B
bellard 已提交
352
#if defined(TARGET_I386)
A
aliguori 已提交
353 354
        monitor_printf(mon, " pc=0x" TARGET_FMT_lx,
                       env->eip + env->segs[R_CS].base);
B
bellard 已提交
355
#elif defined(TARGET_PPC)
A
aliguori 已提交
356
        monitor_printf(mon, " nip=0x" TARGET_FMT_lx, env->nip);
B
bellard 已提交
357
#elif defined(TARGET_SPARC)
A
aliguori 已提交
358 359
        monitor_printf(mon, " pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx,
                       env->pc, env->npc);
360
#elif defined(TARGET_MIPS)
A
aliguori 已提交
361
        monitor_printf(mon, " PC=0x" TARGET_FMT_lx, env->active_tc.PC);
B
bellard 已提交
362
#endif
363
        if (env->halted)
A
aliguori 已提交
364 365
            monitor_printf(mon, " (halted)");
        monitor_printf(mon, "\n");
B
bellard 已提交
366 367 368
    }
}

A
aliguori 已提交
369
static void do_cpu_set(Monitor *mon, int index)
B
bellard 已提交
370 371
{
    if (mon_set_cpu(index) < 0)
A
aliguori 已提交
372
        monitor_printf(mon, "Invalid CPU index\n");
B
bellard 已提交
373 374
}

A
aliguori 已提交
375
static void do_info_jit(Monitor *mon)
B
bellard 已提交
376
{
A
aliguori 已提交
377
    dump_exec_info((FILE *)mon, monitor_fprintf);
B
bellard 已提交
378 379
}

A
aliguori 已提交
380
static void do_info_history(Monitor *mon)
B
bellard 已提交
381 382
{
    int i;
383
    const char *str;
384

385 386
    if (!mon->rs)
        return;
387 388
    i = 0;
    for(;;) {
389
        str = readline_get_history(mon->rs, i);
390 391
        if (!str)
            break;
A
aliguori 已提交
392
        monitor_printf(mon, "%d: '%s'\n", i, str);
B
bellard 已提交
393
        i++;
B
bellard 已提交
394 395 396
    }
}

397 398
#if defined(TARGET_PPC)
/* XXX: not implemented in other targets */
A
aliguori 已提交
399
static void do_info_cpu_stats(Monitor *mon)
400 401 402 403
{
    CPUState *env;

    env = mon_get_cpu();
A
aliguori 已提交
404
    cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
405 406 407
}
#endif

A
aliguori 已提交
408
static void do_quit(Monitor *mon)
B
bellard 已提交
409 410 411 412
{
    exit(0);
}

A
aliguori 已提交
413
static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
B
bellard 已提交
414 415 416 417
{
    if (bdrv_is_inserted(bs)) {
        if (!force) {
            if (!bdrv_is_removable(bs)) {
A
aliguori 已提交
418
                monitor_printf(mon, "device is not removable\n");
B
bellard 已提交
419 420 421
                return -1;
            }
            if (bdrv_is_locked(bs)) {
A
aliguori 已提交
422
                monitor_printf(mon, "device is locked\n");
B
bellard 已提交
423 424 425 426 427 428 429 430
                return -1;
            }
        }
        bdrv_close(bs);
    }
    return 0;
}

A
aliguori 已提交
431
static void do_eject(Monitor *mon, int force, const char *filename)
B
bellard 已提交
432 433 434
{
    BlockDriverState *bs;

435
    bs = bdrv_find(filename);
B
bellard 已提交
436
    if (!bs) {
A
aliguori 已提交
437
        monitor_printf(mon, "device not found\n");
B
bellard 已提交
438 439
        return;
    }
A
aliguori 已提交
440
    eject_device(mon, bs, force);
B
bellard 已提交
441 442
}

A
aliguori 已提交
443 444
static void do_change_block(Monitor *mon, const char *device,
                            const char *filename, const char *fmt)
B
bellard 已提交
445 446
{
    BlockDriverState *bs;
447
    BlockDriver *drv = NULL;
B
bellard 已提交
448

449
    bs = bdrv_find(device);
B
bellard 已提交
450
    if (!bs) {
A
aliguori 已提交
451
        monitor_printf(mon, "device not found\n");
B
bellard 已提交
452 453
        return;
    }
454 455 456
    if (fmt) {
        drv = bdrv_find_format(fmt);
        if (!drv) {
A
aliguori 已提交
457
            monitor_printf(mon, "invalid format %s\n", fmt);
458 459 460
            return;
        }
    }
A
aliguori 已提交
461
    if (eject_device(mon, bs, 0) < 0)
B
bellard 已提交
462
        return;
463
    bdrv_open2(bs, filename, 0, drv);
A
aliguori 已提交
464
    monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
465 466
}

A
aliguori 已提交
467 468
static void change_vnc_password_cb(Monitor *mon, const char *password,
                                   void *opaque)
469 470
{
    if (vnc_display_password(NULL, password) < 0)
A
aliguori 已提交
471
        monitor_printf(mon, "could not set VNC server password\n");
472

473
    monitor_read_command(mon, 1);
B
bellard 已提交
474 475
}

A
aliguori 已提交
476
static void do_change_vnc(Monitor *mon, const char *target, const char *arg)
477
{
478
    if (strcmp(target, "passwd") == 0 ||
479 480
        strcmp(target, "password") == 0) {
        if (arg) {
481
            char password[9];
482 483
            strncpy(password, arg, sizeof(password));
            password[sizeof(password) - 1] = '\0';
A
aliguori 已提交
484
            change_vnc_password_cb(mon, password, NULL);
485
        } else {
A
aliguori 已提交
486
            monitor_read_password(mon, change_vnc_password_cb, NULL);
487
        }
488
    } else {
489
        if (vnc_display_open(NULL, target) < 0)
A
aliguori 已提交
490
            monitor_printf(mon, "could not start VNC server on %s\n", target);
491
    }
492 493
}

A
aliguori 已提交
494 495
static void do_change(Monitor *mon, const char *device, const char *target,
                      const char *arg)
496 497
{
    if (strcmp(device, "vnc") == 0) {
498
        do_change_vnc(mon, target, arg);
499
    } else {
500
        do_change_block(mon, device, target, arg);
501 502 503
    }
}

A
aliguori 已提交
504
static void do_screen_dump(Monitor *mon, const char *filename)
B
bellard 已提交
505
{
P
pbrook 已提交
506
    vga_hw_screen_dump(filename);
B
bellard 已提交
507 508
}

A
aliguori 已提交
509
static void do_logfile(Monitor *mon, const char *filename)
P
pbrook 已提交
510 511 512 513
{
    cpu_set_log_filename(filename);
}

A
aliguori 已提交
514
static void do_log(Monitor *mon, const char *items)
515 516
{
    int mask;
517

518
    if (!strcmp(items, "none")) {
519 520
        mask = 0;
    } else {
521
        mask = cpu_str_to_log_mask(items);
522
        if (!mask) {
A
aliguori 已提交
523
            help_cmd(mon, "log");
524 525 526 527 528 529
            return;
        }
    }
    cpu_set_log(mask);
}

530 531 532 533 534 535 536 537 538 539 540
static void do_singlestep(Monitor *mon, const char *option)
{
    if (!option || !strcmp(option, "on")) {
        singlestep = 1;
    } else if (!strcmp(option, "off")) {
        singlestep = 0;
    } else {
        monitor_printf(mon, "unexpected option %s\n", option);
    }
}

A
aliguori 已提交
541
static void do_stop(Monitor *mon)
542 543 544 545
{
    vm_stop(EXCP_INTERRUPT);
}

546
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
547

A
aliguori 已提交
548 549 550 551 552 553
struct bdrv_iterate_context {
    Monitor *mon;
    int err;
};

static void do_cont(Monitor *mon)
554
{
A
aliguori 已提交
555
    struct bdrv_iterate_context context = { mon, 0 };
556

A
aliguori 已提交
557
    bdrv_iterate(encrypted_bdrv_it, &context);
558
    /* only resume the vm if all keys are set and valid */
A
aliguori 已提交
559
    if (!context.err)
560
        vm_start();
561 562
}

563 564
static void bdrv_key_cb(void *opaque, int err)
{
A
aliguori 已提交
565 566
    Monitor *mon = opaque;

567 568
    /* another key was set successfully, retry to continue */
    if (!err)
A
aliguori 已提交
569
        do_cont(mon);
570 571 572 573
}

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

A
aliguori 已提交
576 577 578 579
    if (!context->err && bdrv_key_required(bs)) {
        context->err = -EBUSY;
        monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
                                    context->mon);
580 581 582
    }
}

B
bellard 已提交
583
#ifdef CONFIG_GDBSTUB
584 585 586 587 588 589 590 591
static void do_gdbserver(Monitor *mon, const char *device)
{
    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) {
592
        monitor_printf(mon, "Disabled gdbserver\n");
593
    } else {
594 595
        monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
                       device);
596 597
    }
}
B
bellard 已提交
598
#endif
599

A
aliguori 已提交
600
static void monitor_printc(Monitor *mon, int c)
601
{
A
aliguori 已提交
602
    monitor_printf(mon, "'");
603 604
    switch(c) {
    case '\'':
A
aliguori 已提交
605
        monitor_printf(mon, "\\'");
606 607
        break;
    case '\\':
A
aliguori 已提交
608
        monitor_printf(mon, "\\\\");
609 610
        break;
    case '\n':
A
aliguori 已提交
611
        monitor_printf(mon, "\\n");
612 613
        break;
    case '\r':
A
aliguori 已提交
614
        monitor_printf(mon, "\\r");
615 616 617
        break;
    default:
        if (c >= 32 && c <= 126) {
A
aliguori 已提交
618
            monitor_printf(mon, "%c", c);
619
        } else {
A
aliguori 已提交
620
            monitor_printf(mon, "\\x%02x", c);
621 622 623
        }
        break;
    }
A
aliguori 已提交
624
    monitor_printf(mon, "'");
625 626
}

A
aliguori 已提交
627
static void memory_dump(Monitor *mon, int count, int format, int wsize,
628
                        target_phys_addr_t addr, int is_physical)
629
{
B
bellard 已提交
630
    CPUState *env;
631 632 633 634 635 636 637
    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 已提交
638 639 640
        env = mon_get_cpu();
        if (!env && !is_physical)
            return;
641
#ifdef TARGET_I386
642
        if (wsize == 2) {
643
            flags = 1;
644 645 646
        } else if (wsize == 4) {
            flags = 0;
        } else {
B
bellard 已提交
647
            /* as default we use the current CS size */
648
            flags = 0;
B
bellard 已提交
649 650
            if (env) {
#ifdef TARGET_X86_64
651
                if ((env->efer & MSR_EFER_LMA) &&
B
bellard 已提交
652 653 654 655 656 657 658
                    (env->segs[R_CS].flags & DESC_L_MASK))
                    flags = 2;
                else
#endif
                if (!(env->segs[R_CS].flags & DESC_B_MASK))
                    flags = 1;
            }
659 660
        }
#endif
A
aliguori 已提交
661
        monitor_disas(mon, env, addr, count, is_physical, flags);
662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
        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) {
691
        if (is_physical)
A
aliguori 已提交
692
            monitor_printf(mon, TARGET_FMT_plx ":", addr);
693
        else
A
aliguori 已提交
694
            monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
695 696 697 698 699 700
        l = len;
        if (l > line_size)
            l = line_size;
        if (is_physical) {
            cpu_physical_memory_rw(addr, buf, l, 0);
        } else {
B
bellard 已提交
701 702 703
            env = mon_get_cpu();
            if (!env)
                break;
704
            if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
A
aliguori 已提交
705
                monitor_printf(mon, " Cannot access memory\n");
706 707
                break;
            }
708
        }
709
        i = 0;
710 711 712 713 714 715 716 717 718 719
        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 已提交
720
                v = (uint32_t)ldl_raw(buf + i);
721 722 723 724 725
                break;
            case 8:
                v = ldq_raw(buf + i);
                break;
            }
A
aliguori 已提交
726
            monitor_printf(mon, " ");
727 728
            switch(format) {
            case 'o':
A
aliguori 已提交
729
                monitor_printf(mon, "%#*" PRIo64, max_digits, v);
730 731
                break;
            case 'x':
A
aliguori 已提交
732
                monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
733 734
                break;
            case 'u':
A
aliguori 已提交
735
                monitor_printf(mon, "%*" PRIu64, max_digits, v);
736 737
                break;
            case 'd':
A
aliguori 已提交
738
                monitor_printf(mon, "%*" PRId64, max_digits, v);
739 740
                break;
            case 'c':
A
aliguori 已提交
741
                monitor_printc(mon, v);
742 743 744 745
                break;
            }
            i += wsize;
        }
A
aliguori 已提交
746
        monitor_printf(mon, "\n");
747 748 749 750 751
        addr += l;
        len -= l;
    }
}

B
bellard 已提交
752 753 754 755 756 757
#if TARGET_LONG_BITS == 64
#define GET_TLONG(h, l) (((uint64_t)(h) << 32) | (l))
#else
#define GET_TLONG(h, l) (l)
#endif

A
aliguori 已提交
758
static void do_memory_dump(Monitor *mon, int count, int format, int size,
B
bellard 已提交
759
                           uint32_t addrh, uint32_t addrl)
760
{
B
bellard 已提交
761
    target_long addr = GET_TLONG(addrh, addrl);
A
aliguori 已提交
762
    memory_dump(mon, count, format, size, addr, 0);
763 764
}

765 766 767 768 769 770
#if TARGET_PHYS_ADDR_BITS > 32
#define GET_TPHYSADDR(h, l) (((uint64_t)(h) << 32) | (l))
#else
#define GET_TPHYSADDR(h, l) (l)
#endif

A
aliguori 已提交
771 772
static void do_physical_memory_dump(Monitor *mon, int count, int format,
                                    int size, uint32_t addrh, uint32_t addrl)
B
bellard 已提交
773

774
{
775
    target_phys_addr_t addr = GET_TPHYSADDR(addrh, addrl);
A
aliguori 已提交
776
    memory_dump(mon, count, format, size, addr, 1);
777 778
}

A
aliguori 已提交
779 780
static void do_print(Monitor *mon, int count, int format, int size,
                     unsigned int valh, unsigned int vall)
781
{
782 783
    target_phys_addr_t val = GET_TPHYSADDR(valh, vall);
#if TARGET_PHYS_ADDR_BITS == 32
784 785
    switch(format) {
    case 'o':
A
aliguori 已提交
786
        monitor_printf(mon, "%#o", val);
787 788
        break;
    case 'x':
A
aliguori 已提交
789
        monitor_printf(mon, "%#x", val);
790 791
        break;
    case 'u':
A
aliguori 已提交
792
        monitor_printf(mon, "%u", val);
793 794 795
        break;
    default:
    case 'd':
A
aliguori 已提交
796
        monitor_printf(mon, "%d", val);
797 798
        break;
    case 'c':
A
aliguori 已提交
799
        monitor_printc(mon, val);
800 801
        break;
    }
B
bellard 已提交
802 803 804
#else
    switch(format) {
    case 'o':
A
aliguori 已提交
805
        monitor_printf(mon, "%#" PRIo64, val);
B
bellard 已提交
806 807
        break;
    case 'x':
A
aliguori 已提交
808
        monitor_printf(mon, "%#" PRIx64, val);
B
bellard 已提交
809 810
        break;
    case 'u':
A
aliguori 已提交
811
        monitor_printf(mon, "%" PRIu64, val);
B
bellard 已提交
812 813 814
        break;
    default:
    case 'd':
A
aliguori 已提交
815
        monitor_printf(mon, "%" PRId64, val);
B
bellard 已提交
816 817
        break;
    case 'c':
A
aliguori 已提交
818
        monitor_printc(mon, val);
B
bellard 已提交
819 820 821
        break;
    }
#endif
A
aliguori 已提交
822
    monitor_printf(mon, "\n");
823 824
}

A
aliguori 已提交
825
static void do_memory_save(Monitor *mon, unsigned int valh, unsigned int vall,
B
bellard 已提交
826 827 828 829 830 831 832 833 834 835 836 837 838 839
                           uint32_t size, const char *filename)
{
    FILE *f;
    target_long addr = GET_TLONG(valh, vall);
    uint32_t l;
    CPUState *env;
    uint8_t buf[1024];

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

    f = fopen(filename, "wb");
    if (!f) {
A
aliguori 已提交
840
        monitor_printf(mon, "could not open '%s'\n", filename);
B
bellard 已提交
841 842 843 844 845 846 847 848 849 850 851 852 853 854
        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);
}

A
aliguori 已提交
855 856 857
static void do_physical_memory_save(Monitor *mon, unsigned int valh,
                                    unsigned int vall, uint32_t size,
                                    const char *filename)
A
aurel32 已提交
858 859 860 861
{
    FILE *f;
    uint32_t l;
    uint8_t buf[1024];
862
    target_phys_addr_t addr = GET_TPHYSADDR(valh, vall); 
A
aurel32 已提交
863 864 865

    f = fopen(filename, "wb");
    if (!f) {
A
aliguori 已提交
866
        monitor_printf(mon, "could not open '%s'\n", filename);
A
aurel32 已提交
867 868 869 870 871 872 873 874 875 876 877 878 879 880 881
        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);
}

A
aliguori 已提交
882
static void do_sum(Monitor *mon, uint32_t start, uint32_t size)
B
bellard 已提交
883 884 885 886 887 888 889 890 891 892 893 894
{
    uint32_t addr;
    uint8_t buf[1];
    uint16_t sum;

    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 已提交
895
    monitor_printf(mon, "%05d\n", sum);
B
bellard 已提交
896 897
}

B
bellard 已提交
898 899 900 901 902 903 904 905
typedef struct {
    int keycode;
    const char *name;
} KeyDef;

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

B
bellard 已提交
907 908
    { 0x38, "alt" },
    { 0xb8, "alt_r" },
909 910
    { 0x64, "altgr" },
    { 0xe4, "altgr_r" },
B
bellard 已提交
911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927
    { 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" },
928 929
    { 0x0c, "minus" },
    { 0x0d, "equal" },
B
bellard 已提交
930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
    { 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" },
963 964 965
    { 0x33, "comma" },
    { 0x34, "dot" },
    { 0x35, "slash" },
966

B
balrog 已提交
967 968
    { 0x37, "asterisk" },

B
bellard 已提交
969
    { 0x39, "spc" },
B
bellard 已提交
970
    { 0x3a, "caps_lock" },
B
bellard 已提交
971 972 973 974 975 976 977 978 979 980
    { 0x3b, "f1" },
    { 0x3c, "f2" },
    { 0x3d, "f3" },
    { 0x3e, "f4" },
    { 0x3f, "f5" },
    { 0x40, "f6" },
    { 0x41, "f7" },
    { 0x42, "f8" },
    { 0x43, "f9" },
    { 0x44, "f10" },
B
bellard 已提交
981
    { 0x45, "num_lock" },
B
bellard 已提交
982 983
    { 0x46, "scroll_lock" },

984 985
    { 0xb5, "kp_divide" },
    { 0x37, "kp_multiply" },
T
ths 已提交
986
    { 0x4a, "kp_subtract" },
987 988 989
    { 0x4e, "kp_add" },
    { 0x9c, "kp_enter" },
    { 0x53, "kp_decimal" },
990
    { 0x54, "sysrq" },
991 992 993 994 995 996 997 998 999 1000 1001

    { 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" },
1002

B
bellard 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
    { 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" },
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
#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 已提交
1039 1040 1041 1042 1043 1044
    { 0, NULL },
};

static int get_keycode(const char *key)
{
    const KeyDef *p;
1045 1046
    char *endp;
    int ret;
B
bellard 已提交
1047 1048 1049 1050 1051

    for(p = key_defs; p->name != NULL; p++) {
        if (!strcmp(key, p->name))
            return p->keycode;
    }
1052 1053 1054 1055 1056
    if (strstart(key, "0x", NULL)) {
        ret = strtoul(key, &endp, 0);
        if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
            return ret;
    }
B
bellard 已提交
1057 1058 1059
    return -1;
}

1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
#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);
    }
}

A
aliguori 已提交
1078 1079
static void do_sendkey(Monitor *mon, const char *string, int has_hold_time,
                       int hold_time)
B
bellard 已提交
1080
{
1081 1082 1083 1084
    char keyname_buf[16];
    char *separator;
    int keyname_len, keycode, i;

1085 1086 1087 1088 1089 1090 1091
    if (nb_pending_keycodes > 0) {
        qemu_del_timer(key_timer);
        release_keys(NULL);
    }
    if (!has_hold_time)
        hold_time = 100;
    i = 0;
1092 1093 1094 1095 1096 1097
    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 已提交
1098
                monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1099
                return;
B
bellard 已提交
1100
            }
1101
            if (i == MAX_KEYCODES) {
A
aliguori 已提交
1102
                monitor_printf(mon, "too many keys\n");
1103 1104 1105 1106 1107
                return;
            }
            keyname_buf[keyname_len] = 0;
            keycode = get_keycode(keyname_buf);
            if (keycode < 0) {
A
aliguori 已提交
1108
                monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1109 1110
                return;
            }
1111
            keycodes[i++] = keycode;
B
bellard 已提交
1112
        }
1113
        if (!separator)
B
bellard 已提交
1114
            break;
1115
        string = separator + 1;
B
bellard 已提交
1116
    }
1117
    nb_pending_keycodes = i;
B
bellard 已提交
1118
    /* key down events */
1119
    for (i = 0; i < nb_pending_keycodes; i++) {
B
bellard 已提交
1120 1121 1122 1123 1124
        keycode = keycodes[i];
        if (keycode & 0x80)
            kbd_put_keycode(0xe0);
        kbd_put_keycode(keycode & 0x7f);
    }
1125
    /* delayed key up events */
1126 1127
    qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
                    muldiv64(ticks_per_sec, hold_time, 1000));
B
bellard 已提交
1128 1129
}

B
bellard 已提交
1130 1131
static int mouse_button_state;

A
aliguori 已提交
1132
static void do_mouse_move(Monitor *mon, const char *dx_str, const char *dy_str,
B
bellard 已提交
1133 1134 1135 1136 1137 1138
                          const char *dz_str)
{
    int dx, dy, dz;
    dx = strtol(dx_str, NULL, 0);
    dy = strtol(dy_str, NULL, 0);
    dz = 0;
1139
    if (dz_str)
B
bellard 已提交
1140 1141 1142 1143
        dz = strtol(dz_str, NULL, 0);
    kbd_mouse_event(dx, dy, dz, mouse_button_state);
}

A
aliguori 已提交
1144
static void do_mouse_button(Monitor *mon, int button_state)
B
bellard 已提交
1145 1146 1147 1148 1149
{
    mouse_button_state = button_state;
    kbd_mouse_event(0, 0, 0, mouse_button_state);
}

A
aliguori 已提交
1150 1151
static void do_ioport_read(Monitor *mon, int count, int format, int size,
                           int addr, int has_index, int index)
B
bellard 已提交
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
{
    uint32_t val;
    int suffix;

    if (has_index) {
        cpu_outb(NULL, addr & 0xffff, index & 0xff);
        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 已提交
1177 1178
    monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
                   suffix, addr, size * 2, val);
B
bellard 已提交
1179
}
B
bellard 已提交
1180

1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
/* boot_set handler */
static QEMUBootSetHandler *qemu_boot_set_handler = NULL;
static void *boot_opaque;

void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
{
    qemu_boot_set_handler = func;
    boot_opaque = opaque;
}

A
aliguori 已提交
1191
static void do_boot_set(Monitor *mon, const char *bootdevice)
1192 1193 1194 1195
{
    int res;

    if (qemu_boot_set_handler)  {
1196
        res = qemu_boot_set_handler(boot_opaque, bootdevice);
1197
        if (res == 0)
A
aliguori 已提交
1198 1199
            monitor_printf(mon, "boot device list now set to %s\n",
                           bootdevice);
1200
        else
A
aliguori 已提交
1201 1202
            monitor_printf(mon, "setting boot device list failed with "
                           "error %i\n", res);
1203
    } else {
A
aliguori 已提交
1204 1205
        monitor_printf(mon, "no function defined to set boot device list for "
                       "this architecture\n");
1206 1207 1208
    }
}

A
aliguori 已提交
1209
static void do_system_reset(Monitor *mon)
B
bellard 已提交
1210 1211 1212 1213
{
    qemu_system_reset_request();
}

A
aliguori 已提交
1214
static void do_system_powerdown(Monitor *mon)
B
bellard 已提交
1215 1216 1217 1218
{
    qemu_system_powerdown_request();
}

B
bellard 已提交
1219
#if defined(TARGET_I386)
A
aliguori 已提交
1220
static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
B
bellard 已提交
1221
{
A
aliguori 已提交
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
    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 已提交
1233 1234
}

A
aliguori 已提交
1235
static void tlb_info(Monitor *mon)
B
bellard 已提交
1236
{
B
bellard 已提交
1237
    CPUState *env;
B
bellard 已提交
1238 1239 1240
    int l1, l2;
    uint32_t pgd, pde, pte;

B
bellard 已提交
1241 1242 1243 1244
    env = mon_get_cpu();
    if (!env)
        return;

B
bellard 已提交
1245
    if (!(env->cr[0] & CR0_PG_MASK)) {
A
aliguori 已提交
1246
        monitor_printf(mon, "PG disabled\n");
B
bellard 已提交
1247 1248 1249 1250 1251 1252 1253 1254
        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 已提交
1255
                print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
B
bellard 已提交
1256 1257
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1258
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
B
bellard 已提交
1259 1260 1261
                                             (uint8_t *)&pte, 4);
                    pte = le32_to_cpu(pte);
                    if (pte & PG_PRESENT_MASK) {
A
aliguori 已提交
1262
                        print_pte(mon, (l1 << 22) + (l2 << 12),
1263
                                  pte & ~PG_PSE_MASK,
B
bellard 已提交
1264 1265 1266 1267 1268 1269 1270 1271
                                  ~0xfff);
                    }
                }
            }
        }
    }
}

A
aliguori 已提交
1272
static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
B
bellard 已提交
1273 1274
                      uint32_t end, int prot)
{
B
bellard 已提交
1275 1276 1277
    int prot1;
    prot1 = *plast_prot;
    if (prot != prot1) {
B
bellard 已提交
1278
        if (*pstart != -1) {
A
aliguori 已提交
1279 1280 1281 1282 1283
            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 已提交
1284 1285 1286 1287 1288 1289 1290 1291 1292
        }
        if (prot != 0)
            *pstart = end;
        else
            *pstart = -1;
        *plast_prot = prot;
    }
}

A
aliguori 已提交
1293
static void mem_info(Monitor *mon)
B
bellard 已提交
1294
{
B
bellard 已提交
1295
    CPUState *env;
B
bellard 已提交
1296 1297 1298
    int l1, l2, prot, last_prot;
    uint32_t pgd, pde, pte, start, end;

B
bellard 已提交
1299 1300 1301 1302
    env = mon_get_cpu();
    if (!env)
        return;

B
bellard 已提交
1303
    if (!(env->cr[0] & CR0_PG_MASK)) {
A
aliguori 已提交
1304
        monitor_printf(mon, "PG disabled\n");
B
bellard 已提交
1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
        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 已提交
1317
                mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1318 1319
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1320
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
B
bellard 已提交
1321 1322 1323 1324 1325 1326 1327 1328
                                             (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 已提交
1329
                    mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1330 1331 1332 1333
                }
            }
        } else {
            prot = 0;
A
aliguori 已提交
1334
            mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1335 1336 1337 1338 1339
        }
    }
}
#endif

A
aurel32 已提交
1340 1341
#if defined(TARGET_SH4)

A
aliguori 已提交
1342
static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
A
aurel32 已提交
1343
{
A
aliguori 已提交
1344 1345 1346 1347 1348 1349 1350 1351
    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 已提交
1352 1353
}

A
aliguori 已提交
1354
static void tlb_info(Monitor *mon)
A
aurel32 已提交
1355 1356 1357 1358
{
    CPUState *env = mon_get_cpu();
    int i;

A
aliguori 已提交
1359
    monitor_printf (mon, "ITLB:\n");
A
aurel32 已提交
1360
    for (i = 0 ; i < ITLB_SIZE ; i++)
A
aliguori 已提交
1361 1362
        print_tlb (mon, i, &env->itlb[i]);
    monitor_printf (mon, "UTLB:\n");
A
aurel32 已提交
1363
    for (i = 0 ; i < UTLB_SIZE ; i++)
A
aliguori 已提交
1364
        print_tlb (mon, i, &env->utlb[i]);
A
aurel32 已提交
1365 1366 1367 1368
}

#endif

A
aliguori 已提交
1369
static void do_info_kqemu(Monitor *mon)
B
bellard 已提交
1370 1371
{
#ifdef USE_KQEMU
B
bellard 已提交
1372
    CPUState *env;
B
bellard 已提交
1373 1374
    int val;
    val = 0;
B
bellard 已提交
1375 1376
    env = mon_get_cpu();
    if (!env) {
A
aliguori 已提交
1377
        monitor_printf(mon, "No cpu initialized yet");
B
bellard 已提交
1378 1379 1380
        return;
    }
    val = env->kqemu_enabled;
A
aliguori 已提交
1381
    monitor_printf(mon, "kqemu support: ");
B
bellard 已提交
1382 1383 1384
    switch(val) {
    default:
    case 0:
A
aliguori 已提交
1385
        monitor_printf(mon, "disabled\n");
B
bellard 已提交
1386 1387
        break;
    case 1:
A
aliguori 已提交
1388
        monitor_printf(mon, "enabled for user code\n");
B
bellard 已提交
1389 1390
        break;
    case 2:
A
aliguori 已提交
1391
        monitor_printf(mon, "enabled for user and kernel code\n");
B
bellard 已提交
1392 1393
        break;
    }
B
bellard 已提交
1394
#else
A
aliguori 已提交
1395
    monitor_printf(mon, "kqemu support: not compiled\n");
B
bellard 已提交
1396
#endif
1397
}
B
bellard 已提交
1398

A
aliguori 已提交
1399
static void do_info_kvm(Monitor *mon)
A
aliguori 已提交
1400 1401
{
#ifdef CONFIG_KVM
A
aliguori 已提交
1402
    monitor_printf(mon, "kvm support: ");
A
aliguori 已提交
1403
    if (kvm_enabled())
A
aliguori 已提交
1404
        monitor_printf(mon, "enabled\n");
A
aliguori 已提交
1405
    else
A
aliguori 已提交
1406
        monitor_printf(mon, "disabled\n");
A
aliguori 已提交
1407
#else
A
aliguori 已提交
1408
    monitor_printf(mon, "kvm support: not compiled\n");
A
aliguori 已提交
1409 1410 1411
#endif
}

B
bellard 已提交
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
#ifdef CONFIG_PROFILER

int64_t kqemu_time;
int64_t qemu_time;
int64_t kqemu_exec_count;
int64_t dev_time;
int64_t kqemu_ret_int_count;
int64_t kqemu_ret_excp_count;
int64_t kqemu_ret_intr_count;

A
aliguori 已提交
1422
static void do_info_profile(Monitor *mon)
B
bellard 已提交
1423 1424 1425 1426 1427
{
    int64_t total;
    total = qemu_time;
    if (total == 0)
        total = 1;
A
aliguori 已提交
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
    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);
    monitor_printf(mon, "kqemu time  %" PRId64 " (%0.3f %0.1f%%) count=%"
                        PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%"
                        PRId64 "\n",
                   kqemu_time, kqemu_time / (double)ticks_per_sec,
                   kqemu_time / (double)total * 100.0,
                   kqemu_exec_count,
                   kqemu_ret_int_count,
                   kqemu_ret_excp_count,
                   kqemu_ret_intr_count);
B
bellard 已提交
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
    qemu_time = 0;
    kqemu_time = 0;
    kqemu_exec_count = 0;
    dev_time = 0;
    kqemu_ret_int_count = 0;
    kqemu_ret_excp_count = 0;
    kqemu_ret_intr_count = 0;
#ifdef USE_KQEMU
    kqemu_record_dump();
#endif
}
#else
A
aliguori 已提交
1453
static void do_info_profile(Monitor *mon)
B
bellard 已提交
1454
{
A
aliguori 已提交
1455
    monitor_printf(mon, "Internal profiler not compiled\n");
B
bellard 已提交
1456 1457 1458
}
#endif

B
bellard 已提交
1459 1460 1461
/* Capture support */
static LIST_HEAD (capture_list_head, CaptureState) capture_head;

A
aliguori 已提交
1462
static void do_info_capture(Monitor *mon)
B
bellard 已提交
1463 1464 1465 1466 1467
{
    int i;
    CaptureState *s;

    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
A
aliguori 已提交
1468
        monitor_printf(mon, "[%d]: ", i);
B
bellard 已提交
1469 1470 1471 1472
        s->ops.info (s->opaque);
    }
}

A
aliguori 已提交
1473
static void do_stop_capture(Monitor *mon, int n)
B
bellard 已提交
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
{
    int i;
    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;
        }
    }
}

#ifdef HAS_AUDIO
A
aliguori 已提交
1489 1490 1491 1492
static void do_wav_capture(Monitor *mon, const char *path,
                           int has_freq, int freq,
                           int has_bits, int bits,
                           int has_channels, int nchannels)
B
bellard 已提交
1493 1494 1495 1496 1497 1498 1499 1500 1501 1502
{
    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 已提交
1503
        monitor_printf(mon, "Faied to add wave capture\n");
B
bellard 已提交
1504 1505 1506 1507 1508 1509
        qemu_free (s);
    }
    LIST_INSERT_HEAD (&capture_head, s, entries);
}
#endif

A
aurel32 已提交
1510
#if defined(TARGET_I386)
A
aliguori 已提交
1511
static void do_inject_nmi(Monitor *mon, int cpu_index)
A
aurel32 已提交
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522
{
    CPUState *env;

    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 已提交
1523
static void do_info_status(Monitor *mon)
A
aurel32 已提交
1524
{
1525 1526 1527 1528 1529 1530 1531
    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 已提交
1532
       monitor_printf(mon, "VM status: paused\n");
A
aurel32 已提交
1533 1534 1535
}


A
aliguori 已提交
1536
static void do_balloon(Monitor *mon, int value)
A
aliguori 已提交
1537 1538 1539 1540 1541
{
    ram_addr_t target = value;
    qemu_balloon(target << 20);
}

A
aliguori 已提交
1542
static void do_info_balloon(Monitor *mon)
A
aliguori 已提交
1543 1544 1545 1546
{
    ram_addr_t actual;

    actual = qemu_balloon_status();
A
aliguori 已提交
1547
    if (kvm_enabled() && !kvm_has_sync_mmu())
A
aliguori 已提交
1548 1549
        monitor_printf(mon, "Using KVM without synchronous MMU, "
                       "ballooning disabled\n");
A
aliguori 已提交
1550
    else if (actual == 0)
A
aliguori 已提交
1551
        monitor_printf(mon, "Ballooning not activated in VM\n");
A
aliguori 已提交
1552
    else
A
aliguori 已提交
1553
        monitor_printf(mon, "balloon: actual=%d\n", (int)(actual >> 20));
A
aliguori 已提交
1554 1555
}

1556 1557
static void do_acl(Monitor *mon,
                   const char *command,
1558 1559 1560 1561
                   const char *aclname,
                   const char *match,
                   int has_index,
                   int index)
1562 1563 1564 1565 1566
{
    qemu_acl *acl;

    acl = qemu_acl_find(aclname);
    if (!acl) {
1567 1568
        monitor_printf(mon, "acl: unknown list '%s'\n", aclname);
        return;
1569 1570 1571
    }

    if (strcmp(command, "show") == 0) {
1572 1573 1574
        int i = 0;
        qemu_acl_entry *entry;
        monitor_printf(mon, "policy: %s\n",
1575
                       acl->defaultDeny ? "deny" : "allow");
1576 1577 1578
        TAILQ_FOREACH(entry, &acl->entries, next) {
            i++;
            monitor_printf(mon, "%d: %s %s\n", i,
1579 1580
                           entry->deny ? "deny" : "allow",
                           entry->match);
1581
        }
1582
    } else if (strcmp(command, "reset") == 0) {
1583 1584
        qemu_acl_reset(acl);
        monitor_printf(mon, "acl: removed all rules\n");
1585
    } else if (strcmp(command, "policy") == 0) {
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599
        if (!match) {
            monitor_printf(mon, "acl: missing policy parameter\n");
            return;
        }

        if (strcmp(match, "allow") == 0) {
            acl->defaultDeny = 0;
            monitor_printf(mon, "acl: policy set to 'allow'\n");
        } else if (strcmp(match, "deny") == 0) {
            acl->defaultDeny = 1;
            monitor_printf(mon, "acl: policy set to 'deny'\n");
        } else {
            monitor_printf(mon, "acl: unknown policy '%s', expected 'deny' or 'allow'\n", match);
        }
1600
    } else if ((strcmp(command, "allow") == 0) ||
1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
               (strcmp(command, "deny") == 0)) {
        int deny = strcmp(command, "deny") == 0 ? 1 : 0;
        int ret;

        if (!match) {
            monitor_printf(mon, "acl: missing match parameter\n");
            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);
1618
    } else if (strcmp(command, "remove") == 0) {
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
        int ret;

        if (!match) {
            monitor_printf(mon, "acl: missing match parameter\n");
            return;
        }

        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);
1631
    } else {
1632
        monitor_printf(mon, "acl: unknown command '%s'\n", command);
1633 1634 1635
    }
}

B
blueswir1 已提交
1636
/* Please update qemu-doc.texi when adding or changing commands */
A
aliguori 已提交
1637 1638
static const mon_cmd_t mon_cmds[] = {
    { "help|?", "s?", help_cmd,
B
bellard 已提交
1639
      "[cmd]", "show the help" },
1640
    { "commit", "s", do_commit,
B
bellard 已提交
1641
      "device|all", "commit changes to the disk images (if -snapshot is used) or backing files" },
1642
    { "info", "s?", do_info,
1643
      "[subcommand]", "show various information about the system state" },
1644
    { "q|quit", "", do_quit,
B
bellard 已提交
1645
      "", "quit the emulator" },
B
bellard 已提交
1646
    { "eject", "-fB", do_eject,
T
ths 已提交
1647
      "[-f] device", "eject a removable medium (use -f to force it)" },
1648 1649
    { "change", "BFs?", do_change,
      "device filename [format]", "change a removable medium, optional format" },
1650
    { "screendump", "F", do_screen_dump,
B
bellard 已提交
1651
      "filename", "save screen into PPM image 'filename'" },
1652
    { "logfile", "F", do_logfile,
P
pbrook 已提交
1653
      "filename", "output logs to 'filename'" },
1654
    { "log", "s", do_log,
1655
      "item1[,...]", "activate logging of the specified items to '/tmp/qemu.log'" },
B
bellard 已提交
1656
    { "savevm", "s?", do_savevm,
1657
      "[tag|id]", "save a VM snapshot. If no tag or id are provided, a new snapshot is created" },
B
bellard 已提交
1658
    { "loadvm", "s", do_loadvm,
1659
      "tag|id", "restore a VM snapshot from its tag or id" },
B
bellard 已提交
1660
    { "delvm", "s", do_delvm,
1661
      "tag|id", "delete a VM snapshot from its tag or id" },
1662 1663
    { "singlestep", "s?", do_singlestep,
      "[on|off]", "run emulation in singlestep mode or switch to normal mode", },
1664
    { "stop", "", do_stop,
1665
      "", "stop emulation", },
1666
    { "c|cont", "", do_cont,
1667
      "", "resume emulation", },
B
bellard 已提交
1668
#ifdef CONFIG_GDBSTUB
1669
    { "gdbserver", "s?", do_gdbserver,
1670
      "[device]", "start gdbserver on given device (default 'tcp::1234'), stop with 'none'", },
B
bellard 已提交
1671
#endif
1672
    { "x", "/l", do_memory_dump,
1673
      "/fmt addr", "virtual memory dump starting at 'addr'", },
1674
    { "xp", "/l", do_physical_memory_dump,
1675
      "/fmt addr", "physical memory dump starting at 'addr'", },
1676
    { "p|print", "/l", do_print,
1677
      "/fmt expr", "print expression value (use $reg for CPU register access)", },
1678
    { "i", "/ii.", do_ioport_read,
B
bellard 已提交
1679 1680
      "/fmt addr", "I/O port read" },

1681 1682
    { "sendkey", "si?", do_sendkey,
      "keys [hold_ms]", "send keys to the VM (e.g. 'sendkey ctrl-alt-f1', default hold time=100 ms)" },
1683
    { "system_reset", "", do_system_reset,
B
bellard 已提交
1684
      "", "reset the system" },
1685
    { "system_powerdown", "", do_system_powerdown,
B
bellard 已提交
1686
      "", "send system power down event" },
1687
    { "sum", "ii", do_sum,
B
bellard 已提交
1688
      "addr size", "compute the checksum of a memory region" },
B
bellard 已提交
1689 1690 1691 1692
    { "usb_add", "s", do_usb_add,
      "device", "add USB device (e.g. 'host:bus.addr' or 'host:vendor_id:product_id')" },
    { "usb_del", "s", do_usb_del,
      "device", "remove USB device 'bus.addr'" },
1693
    { "cpu", "i", do_cpu_set,
B
bellard 已提交
1694
      "index", "set the default CPU" },
1695
    { "mouse_move", "sss?", do_mouse_move,
B
bellard 已提交
1696
      "dx dy [dz]", "send mouse move events" },
1697
    { "mouse_button", "i", do_mouse_button,
B
bellard 已提交
1698
      "state", "change mouse button state (1=L, 2=M, 4=R)" },
1699 1700
    { "mouse_set", "i", do_mouse_set,
      "index", "set which mouse device receives events" },
B
bellard 已提交
1701 1702
#ifdef HAS_AUDIO
    { "wavcapture", "si?i?i?", do_wav_capture,
1703
      "path [frequency [bits [channels]]]",
B
bellard 已提交
1704 1705
      "capture audio to a wave file (default frequency=44100 bits=16 channels=2)" },
#endif
B
blueswir1 已提交
1706 1707
    { "stopcapture", "i", do_stop_capture,
      "capture index", "stop capture" },
1708
    { "memsave", "lis", do_memory_save,
B
bellard 已提交
1709
      "addr size file", "save to disk virtual memory dump starting at 'addr' of size 'size'", },
A
aurel32 已提交
1710 1711
    { "pmemsave", "lis", do_physical_memory_save,
      "addr size file", "save to disk physical memory dump starting at 'addr' of size 'size'", },
1712 1713
    { "boot_set", "s", do_boot_set,
      "bootdevice", "define new values for the boot device list" },
A
aurel32 已提交
1714 1715 1716 1717
#if defined(TARGET_I386)
    { "nmi", "i", do_inject_nmi,
      "cpu", "inject an NMI on the given CPU", },
#endif
A
aliguori 已提交
1718 1719 1720 1721 1722 1723
    { "migrate", "-ds", do_migrate,
      "[-d] uri", "migrate to URI (using -d to not wait for completion)" },
    { "migrate_cancel", "", do_migrate_cancel,
      "", "cancel the current VM migration" },
    { "migrate_set_speed", "s", do_migrate_set_speed,
      "value", "set maximum speed (in bytes) for migrations" },
1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737
#if defined(TARGET_I386)
    { "drive_add", "ss", drive_hot_add, "pci_addr=[[<domain>:]<bus>:]<slot>\n"
                                         "[file=file][,if=type][,bus=n]\n"
                                        "[,unit=m][,media=d][index=i]\n"
                                        "[,cyls=c,heads=h,secs=s[,trans=t]]\n"
                                        "[snapshot=on|off][,cache=on|off]",
                                        "add drive to PCI storage controller" },
    { "pci_add", "sss", pci_device_hot_add, "pci_addr=auto|[[<domain>:]<bus>:]<slot> nic|storage [[vlan=n][,macaddr=addr][,model=type]] [file=file][,if=type][,bus=nr]...", "hot-add PCI device" },
    { "pci_del", "s", pci_device_hot_remove, "pci_addr=[[<domain>:]<bus>:]<slot>", "hot remove PCI device" },
    { "host_net_add", "ss", net_host_device_add,
      "[tap,user,socket,vde] options", "add host VLAN client" },
    { "host_net_remove", "is", net_host_device_remove,
      "vlan_id name", "remove host VLAN client" },
#endif
A
aliguori 已提交
1738 1739
    { "balloon", "i", do_balloon,
      "target", "request VM to change it's memory allocation (in MB)" },
1740
    { "set_link", "ss", do_set_link,
1741 1742
      "name up|down", "change the link status of a network adapter" },
    { "acl", "sss?i?", do_acl, "<command> <aclname> [<match> [<index>]]\n",
1743 1744 1745 1746 1747
                               "acl show vnc.username\n"
                               "acl policy vnc.username deny\n"
                               "acl allow vnc.username fred\n"
                               "acl deny vnc.username bob\n"
                               "acl reset vnc.username\n" },
1748
    { NULL, NULL, },
B
bellard 已提交
1749 1750
};

B
blueswir1 已提交
1751
/* Please update qemu-doc.texi when adding or changing commands */
A
aliguori 已提交
1752
static const mon_cmd_t info_cmds[] = {
B
bellard 已提交
1753
    { "version", "", do_info_version,
B
blueswir1 已提交
1754
      "", "show the version of QEMU" },
1755
    { "network", "", do_info_network,
B
bellard 已提交
1756
      "", "show the network state" },
1757 1758
    { "chardev", "", qemu_chr_info,
      "", "show the character devices" },
A
aliguori 已提交
1759
    { "block", "", bdrv_info,
B
bellard 已提交
1760
      "", "show the block devices" },
A
aliguori 已提交
1761
    { "blockstats", "", bdrv_info_stats,
1762
      "", "show block device statistics" },
1763 1764
    { "registers", "", do_info_registers,
      "", "show the cpu registers" },
B
bellard 已提交
1765 1766
    { "cpus", "", do_info_cpus,
      "", "show infos for each CPU" },
B
bellard 已提交
1767 1768
    { "history", "", do_info_history,
      "", "show the command line history", },
1769 1770
    { "irq", "", irq_info,
      "", "show the interrupts statistics (if available)", },
1771 1772
    { "pic", "", pic_info,
      "", "show i8259 (PIC) state", },
B
bellard 已提交
1773 1774
    { "pci", "", pci_info,
      "", "show PCI info", },
A
aurel32 已提交
1775
#if defined(TARGET_I386) || defined(TARGET_SH4)
B
bellard 已提交
1776 1777
    { "tlb", "", tlb_info,
      "", "show virtual to physical memory mappings", },
A
aurel32 已提交
1778 1779
#endif
#if defined(TARGET_I386)
B
bellard 已提交
1780 1781
    { "mem", "", mem_info,
      "", "show the active virtual memory mappings", },
A
aliguori 已提交
1782 1783
    { "hpet", "", do_info_hpet,
      "", "show state of HPET", },
B
bellard 已提交
1784
#endif
B
bellard 已提交
1785 1786
    { "jit", "", do_info_jit,
      "", "show dynamic compiler info", },
B
bellard 已提交
1787
    { "kqemu", "", do_info_kqemu,
B
blueswir1 已提交
1788
      "", "show KQEMU information", },
A
aliguori 已提交
1789
    { "kvm", "", do_info_kvm,
B
blueswir1 已提交
1790
      "", "show KVM information", },
B
bellard 已提交
1791 1792 1793 1794
    { "usb", "", usb_info,
      "", "show guest USB devices", },
    { "usbhost", "", usb_host_info,
      "", "show host USB devices", },
B
bellard 已提交
1795 1796
    { "profile", "", do_info_profile,
      "", "show profiling information", },
B
bellard 已提交
1797
    { "capture", "", do_info_capture,
B
bellard 已提交
1798
      "", "show capture information" },
B
bellard 已提交
1799
    { "snapshots", "", do_info_snapshots,
B
bellard 已提交
1800
      "", "show the currently saved VM snapshots" },
A
aurel32 已提交
1801 1802
    { "status", "", do_info_status,
      "", "show the current VM status (running|paused)" },
1803 1804
    { "pcmcia", "", pcmcia_info,
      "", "show guest PCMCIA status" },
1805 1806
    { "mice", "", do_info_mice,
      "", "show which guest mouse is receiving events" },
B
bellard 已提交
1807 1808
    { "vnc", "", do_info_vnc,
      "", "show the vnc server status"},
T
ths 已提交
1809 1810
    { "name", "", do_info_name,
      "", "show the current VM name" },
1811 1812
    { "uuid", "", do_info_uuid,
      "", "show the current VM UUID" },
1813 1814 1815 1816
#if defined(TARGET_PPC)
    { "cpustats", "", do_info_cpu_stats,
      "", "show CPU statistics", },
#endif
1817 1818 1819 1820
#if defined(CONFIG_SLIRP)
    { "slirp", "", do_info_slirp,
      "", "show SLIRP statistics", },
#endif
A
aliguori 已提交
1821
    { "migrate", "", do_info_migrate, "", "show migration status" },
A
aliguori 已提交
1822 1823
    { "balloon", "", do_info_balloon,
      "", "show balloon information" },
B
bellard 已提交
1824 1825 1826
    { NULL, NULL, },
};

1827 1828 1829 1830 1831
/*******************************************************************/

static const char *pch;
static jmp_buf expr_env;

B
bellard 已提交
1832 1833 1834
#define MD_TLONG 0
#define MD_I32   1

1835 1836 1837
typedef struct MonitorDef {
    const char *name;
    int offset;
B
blueswir1 已提交
1838
    target_long (*get_value)(const struct MonitorDef *md, int val);
B
bellard 已提交
1839
    int type;
1840 1841
} MonitorDef;

B
bellard 已提交
1842
#if defined(TARGET_I386)
B
blueswir1 已提交
1843
static target_long monitor_get_pc (const struct MonitorDef *md, int val)
B
bellard 已提交
1844
{
B
bellard 已提交
1845 1846 1847 1848
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return env->eip + env->segs[R_CS].base;
B
bellard 已提交
1849 1850 1851
}
#endif

1852
#if defined(TARGET_PPC)
B
blueswir1 已提交
1853
static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
1854
{
B
bellard 已提交
1855
    CPUState *env = mon_get_cpu();
1856 1857 1858
    unsigned int u;
    int i;

B
bellard 已提交
1859 1860 1861
    if (!env)
        return 0;

1862 1863
    u = 0;
    for (i = 0; i < 8; i++)
1864
        u |= env->crf[i] << (32 - (4 * i));
1865 1866 1867 1868

    return u;
}

B
blueswir1 已提交
1869
static target_long monitor_get_msr (const struct MonitorDef *md, int val)
1870
{
B
bellard 已提交
1871 1872 1873
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
1874
    return env->msr;
1875 1876
}

B
blueswir1 已提交
1877
static target_long monitor_get_xer (const struct MonitorDef *md, int val)
1878
{
B
bellard 已提交
1879 1880 1881
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
A
aurel32 已提交
1882
    return env->xer;
1883
}
1884

B
blueswir1 已提交
1885
static target_long monitor_get_decr (const struct MonitorDef *md, int val)
1886
{
B
bellard 已提交
1887 1888 1889 1890
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_decr(env);
1891 1892
}

B
blueswir1 已提交
1893
static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
1894
{
B
bellard 已提交
1895 1896 1897 1898
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_tbu(env);
1899 1900
}

B
blueswir1 已提交
1901
static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
1902
{
B
bellard 已提交
1903 1904 1905 1906
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_tbl(env);
1907
}
1908 1909
#endif

1910
#if defined(TARGET_SPARC)
B
bellard 已提交
1911
#ifndef TARGET_SPARC64
B
blueswir1 已提交
1912
static target_long monitor_get_psr (const struct MonitorDef *md, int val)
1913
{
B
bellard 已提交
1914 1915 1916 1917
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return GET_PSR(env);
1918
}
B
bellard 已提交
1919
#endif
1920

B
blueswir1 已提交
1921
static target_long monitor_get_reg(const struct MonitorDef *md, int val)
1922
{
B
bellard 已提交
1923 1924 1925 1926
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return env->regwptr[val];
1927 1928 1929
}
#endif

B
blueswir1 已提交
1930
static const MonitorDef monitor_defs[] = {
1931
#ifdef TARGET_I386
B
bellard 已提交
1932 1933

#define SEG(name, seg) \
B
bellard 已提交
1934
    { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
B
bellard 已提交
1935
    { name ".base", offsetof(CPUState, segs[seg].base) },\
B
bellard 已提交
1936
    { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
B
bellard 已提交
1937

1938 1939 1940 1941 1942 1943 1944
    { "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 已提交
1945
    { "edi", offsetof(CPUState, regs[7]) },
B
bellard 已提交
1946 1947 1948 1949 1950 1951 1952 1953 1954 1955
#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
1956
    { "eflags", offsetof(CPUState, eflags) },
B
bellard 已提交
1957 1958 1959 1960
    { "eip", offsetof(CPUState, eip) },
    SEG("cs", R_CS)
    SEG("ds", R_DS)
    SEG("es", R_ES)
B
bellard 已提交
1961
    SEG("ss", R_SS)
B
bellard 已提交
1962 1963 1964
    SEG("fs", R_FS)
    SEG("gs", R_GS)
    { "pc", 0, monitor_get_pc, },
1965
#elif defined(TARGET_PPC)
J
j_mayer 已提交
1966
    /* General purpose registers */
1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998
    { "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 已提交
1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
    /* 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 已提交
2034
    { "nip|pc", offsetof(CPUState, nip) },
2035 2036
    { "lr", offsetof(CPUState, lr) },
    { "ctr", offsetof(CPUState, ctr) },
2037
    { "decr", 0, &monitor_get_decr, },
2038
    { "ccr", 0, &monitor_get_ccr, },
J
j_mayer 已提交
2039
    /* Machine state register */
2040 2041
    { "msr", 0, &monitor_get_msr, },
    { "xer", 0, &monitor_get_xer, },
2042 2043
    { "tbu", 0, &monitor_get_tbu, },
    { "tbl", 0, &monitor_get_tbl, },
J
j_mayer 已提交
2044 2045 2046 2047 2048
#if defined(TARGET_PPC64)
    /* Address space register */
    { "asr", offsetof(CPUState, asr) },
#endif
    /* Segment registers */
2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066
    { "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 ... */
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 2095 2096 2097 2098 2099 2100 2101 2102
#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 已提交
2103
#ifndef TARGET_SPARC64
2104 2105
    { "psr", 0, &monitor_get_psr, },
    { "wim", offsetof(CPUState, wim) },
B
bellard 已提交
2106
#endif
2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
    { "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 已提交
2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166
#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
2167 2168 2169 2170
#endif
    { NULL },
};

A
aliguori 已提交
2171
static void expr_error(Monitor *mon, const char *msg)
B
bellard 已提交
2172
{
A
aliguori 已提交
2173
    monitor_printf(mon, "%s\n", msg);
2174 2175 2176
    longjmp(expr_env, 1);
}

B
bellard 已提交
2177
/* return 0 if OK, -1 if not found, -2 if no CPU defined */
B
bellard 已提交
2178
static int get_monitor_def(target_long *pval, const char *name)
2179
{
B
blueswir1 已提交
2180
    const MonitorDef *md;
B
bellard 已提交
2181 2182
    void *ptr;

2183 2184 2185
    for(md = monitor_defs; md->name != NULL; md++) {
        if (compare_cmd(name, md->name)) {
            if (md->get_value) {
2186
                *pval = md->get_value(md, md->offset);
2187
            } else {
B
bellard 已提交
2188 2189 2190 2191
                CPUState *env = mon_get_cpu();
                if (!env)
                    return -2;
                ptr = (uint8_t *)env + md->offset;
B
bellard 已提交
2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
                switch(md->type) {
                case MD_I32:
                    *pval = *(int32_t *)ptr;
                    break;
                case MD_TLONG:
                    *pval = *(target_long *)ptr;
                    break;
                default:
                    *pval = 0;
                    break;
                }
2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213
            }
            return 0;
        }
    }
    return -1;
}

static void next(void)
{
    if (pch != '\0') {
        pch++;
2214
        while (qemu_isspace(*pch))
2215 2216 2217 2218
            pch++;
    }
}

A
aliguori 已提交
2219
static int64_t expr_sum(Monitor *mon);
2220

A
aliguori 已提交
2221
static int64_t expr_unary(Monitor *mon)
2222
{
B
blueswir1 已提交
2223
    int64_t n;
2224
    char *p;
B
bellard 已提交
2225
    int ret;
2226 2227 2228 2229

    switch(*pch) {
    case '+':
        next();
A
aliguori 已提交
2230
        n = expr_unary(mon);
2231 2232 2233
        break;
    case '-':
        next();
A
aliguori 已提交
2234
        n = -expr_unary(mon);
2235 2236 2237
        break;
    case '~':
        next();
A
aliguori 已提交
2238
        n = ~expr_unary(mon);
2239 2240 2241
        break;
    case '(':
        next();
A
aliguori 已提交
2242
        n = expr_sum(mon);
2243
        if (*pch != ')') {
A
aliguori 已提交
2244
            expr_error(mon, "')' expected");
2245 2246 2247
        }
        next();
        break;
B
bellard 已提交
2248 2249 2250
    case '\'':
        pch++;
        if (*pch == '\0')
A
aliguori 已提交
2251
            expr_error(mon, "character constant expected");
B
bellard 已提交
2252 2253 2254
        n = *pch;
        pch++;
        if (*pch != '\'')
A
aliguori 已提交
2255
            expr_error(mon, "missing terminating \' character");
B
bellard 已提交
2256 2257
        next();
        break;
2258 2259 2260
    case '$':
        {
            char buf[128], *q;
2261
            target_long reg=0;
2262

2263 2264 2265 2266 2267
            pch++;
            q = buf;
            while ((*pch >= 'a' && *pch <= 'z') ||
                   (*pch >= 'A' && *pch <= 'Z') ||
                   (*pch >= '0' && *pch <= '9') ||
B
bellard 已提交
2268
                   *pch == '_' || *pch == '.') {
2269 2270 2271 2272
                if ((q - buf) < sizeof(buf) - 1)
                    *q++ = *pch;
                pch++;
            }
2273
            while (qemu_isspace(*pch))
2274 2275
                pch++;
            *q = 0;
2276
            ret = get_monitor_def(&reg, buf);
B
bellard 已提交
2277
            if (ret == -1)
A
aliguori 已提交
2278
                expr_error(mon, "unknown register");
2279
            else if (ret == -2)
A
aliguori 已提交
2280
                expr_error(mon, "no cpu defined");
2281
            n = reg;
2282 2283 2284
        }
        break;
    case '\0':
A
aliguori 已提交
2285
        expr_error(mon, "unexpected end of expression");
2286 2287 2288
        n = 0;
        break;
    default:
2289
#if TARGET_PHYS_ADDR_BITS > 32
B
bellard 已提交
2290 2291
        n = strtoull(pch, &p, 0);
#else
2292
        n = strtoul(pch, &p, 0);
B
bellard 已提交
2293
#endif
2294
        if (pch == p) {
A
aliguori 已提交
2295
            expr_error(mon, "invalid char in expression");
2296 2297
        }
        pch = p;
2298
        while (qemu_isspace(*pch))
2299 2300 2301 2302 2303 2304 2305
            pch++;
        break;
    }
    return n;
}


A
aliguori 已提交
2306
static int64_t expr_prod(Monitor *mon)
2307
{
B
blueswir1 已提交
2308
    int64_t val, val2;
B
bellard 已提交
2309
    int op;
2310

A
aliguori 已提交
2311
    val = expr_unary(mon);
2312 2313 2314 2315 2316
    for(;;) {
        op = *pch;
        if (op != '*' && op != '/' && op != '%')
            break;
        next();
A
aliguori 已提交
2317
        val2 = expr_unary(mon);
2318 2319 2320 2321 2322 2323 2324
        switch(op) {
        default:
        case '*':
            val *= val2;
            break;
        case '/':
        case '%':
2325
            if (val2 == 0)
A
aliguori 已提交
2326
                expr_error(mon, "division by zero");
2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
            if (op == '/')
                val /= val2;
            else
                val %= val2;
            break;
        }
    }
    return val;
}

A
aliguori 已提交
2337
static int64_t expr_logic(Monitor *mon)
2338
{
B
blueswir1 已提交
2339
    int64_t val, val2;
B
bellard 已提交
2340
    int op;
2341

A
aliguori 已提交
2342
    val = expr_prod(mon);
2343 2344 2345 2346 2347
    for(;;) {
        op = *pch;
        if (op != '&' && op != '|' && op != '^')
            break;
        next();
A
aliguori 已提交
2348
        val2 = expr_prod(mon);
2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
        switch(op) {
        default:
        case '&':
            val &= val2;
            break;
        case '|':
            val |= val2;
            break;
        case '^':
            val ^= val2;
            break;
        }
    }
    return val;
}

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

A
aliguori 已提交
2370
    val = expr_logic(mon);
2371 2372 2373 2374 2375
    for(;;) {
        op = *pch;
        if (op != '+' && op != '-')
            break;
        next();
A
aliguori 已提交
2376
        val2 = expr_logic(mon);
2377 2378 2379 2380 2381 2382 2383 2384
        if (op == '+')
            val += val2;
        else
            val -= val2;
    }
    return val;
}

A
aliguori 已提交
2385
static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2386 2387 2388 2389 2390 2391
{
    pch = *pp;
    if (setjmp(expr_env)) {
        *pp = pch;
        return -1;
    }
2392
    while (qemu_isspace(*pch))
2393
        pch++;
A
aliguori 已提交
2394
    *pval = expr_sum(mon);
2395 2396 2397 2398 2399 2400 2401 2402 2403 2404
    *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 已提交
2405
    q = buf;
2406
    p = *pp;
2407
    while (qemu_isspace(*p))
2408 2409 2410
        p++;
    if (*p == '\0') {
    fail:
B
bellard 已提交
2411
        *q = '\0';
2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446
        *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 已提交
2447
            qemu_printf("unterminated string\n");
2448 2449 2450 2451
            goto fail;
        }
        p++;
    } else {
2452
        while (*p != '\0' && !qemu_isspace(*p)) {
2453 2454 2455 2456 2457 2458
            if ((q - buf) < buf_size - 1) {
                *q++ = *p;
            }
            p++;
        }
    }
B
bellard 已提交
2459
    *q = '\0';
2460 2461 2462 2463 2464 2465 2466 2467 2468
    *pp = p;
    return 0;
}

static int default_fmt_format = 'x';
static int default_fmt_size = 4;

#define MAX_ARGS 16

A
aliguori 已提交
2469
static void monitor_handle_command(Monitor *mon, const char *cmdline)
2470 2471 2472 2473
{
    const char *p, *pstart, *typestr;
    char *q;
    int c, nb_args, len, i, has_arg;
A
aliguori 已提交
2474
    const mon_cmd_t *cmd;
2475 2476 2477 2478
    char cmdname[256];
    char buf[1024];
    void *str_allocated[MAX_ARGS];
    void *args[MAX_ARGS];
A
aliguori 已提交
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490
    void (*handler_0)(Monitor *mon);
    void (*handler_1)(Monitor *mon, void *arg0);
    void (*handler_2)(Monitor *mon, void *arg0, void *arg1);
    void (*handler_3)(Monitor *mon, void *arg0, void *arg1, void *arg2);
    void (*handler_4)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                      void *arg3);
    void (*handler_5)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                      void *arg3, void *arg4);
    void (*handler_6)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                      void *arg3, void *arg4, void *arg5);
    void (*handler_7)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                      void *arg3, void *arg4, void *arg5, void *arg6);
B
bellard 已提交
2491 2492

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

2496
    /* extract the command name */
B
bellard 已提交
2497
    p = cmdline;
2498
    q = cmdname;
2499
    while (qemu_isspace(*p))
2500 2501 2502 2503
        p++;
    if (*p == '\0')
        return;
    pstart = p;
2504
    while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2505 2506 2507 2508 2509 2510
        p++;
    len = p - pstart;
    if (len > sizeof(cmdname) - 1)
        len = sizeof(cmdname) - 1;
    memcpy(cmdname, pstart, len);
    cmdname[len] = '\0';
2511

2512
    /* find the command */
A
aliguori 已提交
2513
    for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
2514
        if (compare_cmd(cmdname, cmd->name))
2515 2516
            goto found;
    }
A
aliguori 已提交
2517
    monitor_printf(mon, "unknown command: '%s'\n", cmdname);
2518 2519 2520 2521 2522
    return;
 found:

    for(i = 0; i < MAX_ARGS; i++)
        str_allocated[i] = NULL;
2523

2524 2525 2526
    /* parse the parameters */
    typestr = cmd->args_type;
    nb_args = 0;
B
bellard 已提交
2527
    for(;;) {
2528 2529
        c = *typestr;
        if (c == '\0')
B
bellard 已提交
2530
            break;
2531 2532 2533
        typestr++;
        switch(c) {
        case 'F':
B
bellard 已提交
2534
        case 'B':
2535 2536 2537 2538
        case 's':
            {
                int ret;
                char *str;
2539

2540
                while (qemu_isspace(*p))
2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551
                    p++;
                if (*typestr == '?') {
                    typestr++;
                    if (*p == '\0') {
                        /* no optional string: NULL argument */
                        str = NULL;
                        goto add_str;
                    }
                }
                ret = get_str(buf, sizeof(buf), &p);
                if (ret < 0) {
B
bellard 已提交
2552 2553
                    switch(c) {
                    case 'F':
A
aliguori 已提交
2554 2555
                        monitor_printf(mon, "%s: filename expected\n",
                                       cmdname);
B
bellard 已提交
2556 2557
                        break;
                    case 'B':
A
aliguori 已提交
2558 2559
                        monitor_printf(mon, "%s: block device name expected\n",
                                       cmdname);
B
bellard 已提交
2560 2561
                        break;
                    default:
A
aliguori 已提交
2562
                        monitor_printf(mon, "%s: string expected\n", cmdname);
B
bellard 已提交
2563 2564
                        break;
                    }
2565 2566 2567
                    goto fail;
                }
                str = qemu_malloc(strlen(buf) + 1);
B
blueswir1 已提交
2568
                pstrcpy(str, sizeof(buf), buf);
2569 2570 2571 2572
                str_allocated[nb_args] = str;
            add_str:
                if (nb_args >= MAX_ARGS) {
                error_args:
A
aliguori 已提交
2573
                    monitor_printf(mon, "%s: too many arguments\n", cmdname);
2574 2575 2576 2577
                    goto fail;
                }
                args[nb_args++] = str;
            }
B
bellard 已提交
2578
            break;
2579 2580 2581
        case '/':
            {
                int count, format, size;
2582

2583
                while (qemu_isspace(*p))
2584 2585 2586 2587 2588
                    p++;
                if (*p == '/') {
                    /* format found */
                    p++;
                    count = 1;
2589
                    if (qemu_isdigit(*p)) {
2590
                        count = 0;
2591
                        while (qemu_isdigit(*p)) {
2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
                            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:
2630
                    if (*p != '\0' && !qemu_isspace(*p)) {
A
aliguori 已提交
2631 2632
                        monitor_printf(mon, "invalid char in format: '%c'\n",
                                       *p);
2633 2634 2635 2636
                        goto fail;
                    }
                    if (format < 0)
                        format = default_fmt_format;
2637 2638 2639 2640
                    if (format != 'i') {
                        /* for 'i', not specifying a size gives -1 as size */
                        if (size < 0)
                            size = default_fmt_size;
A
aurel32 已提交
2641
                        default_fmt_size = size;
2642
                    }
2643 2644 2645 2646
                    default_fmt_format = format;
                } else {
                    count = 1;
                    format = default_fmt_format;
2647 2648 2649 2650 2651
                    if (format != 'i') {
                        size = default_fmt_size;
                    } else {
                        size = -1;
                    }
2652 2653 2654
                }
                if (nb_args + 3 > MAX_ARGS)
                    goto error_args;
J
j_mayer 已提交
2655 2656 2657
                args[nb_args++] = (void*)(long)count;
                args[nb_args++] = (void*)(long)format;
                args[nb_args++] = (void*)(long)size;
2658
            }
B
bellard 已提交
2659
            break;
2660
        case 'i':
B
bellard 已提交
2661
        case 'l':
2662
            {
B
blueswir1 已提交
2663
                int64_t val;
2664

2665
                while (qemu_isspace(*p))
2666
                    p++;
B
bellard 已提交
2667 2668 2669 2670 2671 2672 2673 2674 2675
                if (*typestr == '?' || *typestr == '.') {
                    if (*typestr == '?') {
                        if (*p == '\0')
                            has_arg = 0;
                        else
                            has_arg = 1;
                    } else {
                        if (*p == '.') {
                            p++;
2676
                            while (qemu_isspace(*p))
B
bellard 已提交
2677 2678 2679 2680 2681 2682
                                p++;
                            has_arg = 1;
                        } else {
                            has_arg = 0;
                        }
                    }
B
bellard 已提交
2683
                    typestr++;
2684 2685
                    if (nb_args >= MAX_ARGS)
                        goto error_args;
J
j_mayer 已提交
2686
                    args[nb_args++] = (void *)(long)has_arg;
2687 2688 2689 2690 2691 2692 2693
                    if (!has_arg) {
                        if (nb_args >= MAX_ARGS)
                            goto error_args;
                        val = -1;
                        goto add_num;
                    }
                }
A
aliguori 已提交
2694
                if (get_expr(mon, &val, &p))
2695 2696
                    goto fail;
            add_num:
B
bellard 已提交
2697 2698 2699
                if (c == 'i') {
                    if (nb_args >= MAX_ARGS)
                        goto error_args;
J
j_mayer 已提交
2700
                    args[nb_args++] = (void *)(long)val;
B
bellard 已提交
2701 2702 2703
                } else {
                    if ((nb_args + 1) >= MAX_ARGS)
                        goto error_args;
2704
#if TARGET_PHYS_ADDR_BITS > 32
J
j_mayer 已提交
2705
                    args[nb_args++] = (void *)(long)((val >> 32) & 0xffffffff);
B
bellard 已提交
2706 2707 2708
#else
                    args[nb_args++] = (void *)0;
#endif
J
j_mayer 已提交
2709
                    args[nb_args++] = (void *)(long)(val & 0xffffffff);
B
bellard 已提交
2710
                }
2711 2712 2713 2714 2715 2716
            }
            break;
        case '-':
            {
                int has_option;
                /* option */
2717

2718 2719 2720
                c = *typestr++;
                if (c == '\0')
                    goto bad_type;
2721
                while (qemu_isspace(*p))
2722 2723 2724 2725 2726
                    p++;
                has_option = 0;
                if (*p == '-') {
                    p++;
                    if (*p != c) {
A
aliguori 已提交
2727 2728
                        monitor_printf(mon, "%s: unsupported option -%c\n",
                                       cmdname, *p);
2729 2730 2731 2732 2733 2734 2735
                        goto fail;
                    }
                    p++;
                    has_option = 1;
                }
                if (nb_args >= MAX_ARGS)
                    goto error_args;
J
j_mayer 已提交
2736
                args[nb_args++] = (void *)(long)has_option;
2737 2738 2739 2740
            }
            break;
        default:
        bad_type:
A
aliguori 已提交
2741
            monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
2742 2743
            goto fail;
        }
B
bellard 已提交
2744
    }
2745
    /* check that all arguments were parsed */
2746
    while (qemu_isspace(*p))
2747 2748
        p++;
    if (*p != '\0') {
A
aliguori 已提交
2749 2750
        monitor_printf(mon, "%s: extraneous characters at the end of line\n",
                       cmdname);
2751
        goto fail;
B
bellard 已提交
2752
    }
2753 2754 2755

    switch(nb_args) {
    case 0:
2756
        handler_0 = cmd->handler;
A
aliguori 已提交
2757
        handler_0(mon);
2758 2759
        break;
    case 1:
2760
        handler_1 = cmd->handler;
A
aliguori 已提交
2761
        handler_1(mon, args[0]);
2762 2763
        break;
    case 2:
2764
        handler_2 = cmd->handler;
A
aliguori 已提交
2765
        handler_2(mon, args[0], args[1]);
2766 2767
        break;
    case 3:
2768
        handler_3 = cmd->handler;
A
aliguori 已提交
2769
        handler_3(mon, args[0], args[1], args[2]);
2770 2771
        break;
    case 4:
2772
        handler_4 = cmd->handler;
A
aliguori 已提交
2773
        handler_4(mon, args[0], args[1], args[2], args[3]);
2774 2775
        break;
    case 5:
2776
        handler_5 = cmd->handler;
A
aliguori 已提交
2777
        handler_5(mon, args[0], args[1], args[2], args[3], args[4]);
2778
        break;
B
bellard 已提交
2779
    case 6:
2780
        handler_6 = cmd->handler;
A
aliguori 已提交
2781
        handler_6(mon, args[0], args[1], args[2], args[3], args[4], args[5]);
B
bellard 已提交
2782
        break;
B
bellard 已提交
2783
    case 7:
2784
        handler_7 = cmd->handler;
A
aliguori 已提交
2785 2786
        handler_7(mon, args[0], args[1], args[2], args[3], args[4], args[5],
                  args[6]);
B
bellard 已提交
2787
        break;
2788
    default:
A
aliguori 已提交
2789
        monitor_printf(mon, "unsupported number of arguments: %d\n", nb_args);
2790
        goto fail;
B
bellard 已提交
2791
    }
2792 2793 2794
 fail:
    for(i = 0; i < MAX_ARGS; i++)
        qemu_free(str_allocated[i]);
B
bellard 已提交
2795 2796 2797
    return;
}

B
bellard 已提交
2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815
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))) {
2816
            readline_add_completion(cur_mon->rs, cmd);
B
bellard 已提交
2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832
        }
        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;

2833
    p = strrchr(input, '/');
B
bellard 已提交
2834 2835 2836
    if (!p) {
        input_path_len = 0;
        pstrcpy(file_prefix, sizeof(file_prefix), input);
B
blueswir1 已提交
2837
        pstrcpy(path, sizeof(path), ".");
B
bellard 已提交
2838 2839 2840 2841 2842 2843 2844 2845 2846
    } 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 已提交
2847 2848
    monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
                   input, path, file_prefix);
B
bellard 已提交
2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859
#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 已提交
2860 2861 2862
            if (input_path_len < sizeof(file))
                pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
                        d->d_name);
B
bellard 已提交
2863 2864 2865 2866 2867
            /* 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 已提交
2868
                pstrcat(file, sizeof(file), "/");
2869
            readline_add_completion(cur_mon->rs, file);
B
bellard 已提交
2870 2871 2872 2873 2874
        }
    }
    closedir(ffs);
}

2875
static void block_completion_it(void *opaque, BlockDriverState *bs)
B
bellard 已提交
2876
{
2877
    const char *name = bdrv_get_device_name(bs);
B
bellard 已提交
2878 2879 2880 2881
    const char *input = opaque;

    if (input[0] == '\0' ||
        !strncmp(name, (char *)input, strlen(input))) {
2882
        readline_add_completion(cur_mon->rs, name);
B
bellard 已提交
2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896
    }
}

/* 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(;;) {
2897
        while (qemu_isspace(*p))
B
bellard 已提交
2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911
            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;
}

2912
static void monitor_find_completion(const char *cmdline)
B
bellard 已提交
2913 2914 2915 2916 2917
{
    const char *cmdname;
    char *args[MAX_ARGS];
    int nb_args, i, len;
    const char *ptype, *str;
A
aliguori 已提交
2918
    const mon_cmd_t *cmd;
2919
    const KeyDef *key;
B
bellard 已提交
2920 2921 2922 2923

    parse_cmdline(cmdline, &nb_args, args);
#ifdef DEBUG_COMPLETION
    for(i = 0; i < nb_args; i++) {
A
aliguori 已提交
2924
        monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
B
bellard 已提交
2925 2926 2927 2928 2929 2930
    }
#endif

    /* if the line ends with a space, it means we want to complete the
       next arg */
    len = strlen(cmdline);
2931
    if (len > 0 && qemu_isspace(cmdline[len - 1])) {
B
bellard 已提交
2932 2933 2934 2935 2936 2937 2938 2939 2940 2941
        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];
2942
        readline_set_completion_index(cur_mon->rs, strlen(cmdname));
A
aliguori 已提交
2943
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
B
bellard 已提交
2944 2945 2946 2947
            cmd_completion(cmdname, cmd->name);
        }
    } else {
        /* find the command */
A
aliguori 已提交
2948
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
B
bellard 已提交
2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965
            if (compare_cmd(args[0], cmd->name))
                goto found;
        }
        return;
    found:
        ptype = cmd->args_type;
        for(i = 0; i < nb_args - 2; i++) {
            if (*ptype != '\0') {
                ptype++;
                while (*ptype == '?')
                    ptype++;
            }
        }
        str = args[nb_args - 1];
        switch(*ptype) {
        case 'F':
            /* file completion */
2966
            readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
2967 2968 2969 2970
            file_completion(str);
            break;
        case 'B':
            /* block device name completion */
2971
            readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
2972 2973
            bdrv_iterate(block_completion_it, (void *)str);
            break;
B
bellard 已提交
2974 2975 2976
        case 's':
            /* XXX: more generic ? */
            if (!strcmp(cmd->name, "info")) {
2977
                readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
2978 2979 2980
                for(cmd = info_cmds; cmd->name != NULL; cmd++) {
                    cmd_completion(str, cmd->name);
                }
2981
            } else if (!strcmp(cmd->name, "sendkey")) {
B
blueswir1 已提交
2982 2983 2984
                char *sep = strrchr(str, '-');
                if (sep)
                    str = sep + 1;
2985
                readline_set_completion_index(cur_mon->rs, strlen(str));
2986 2987 2988
                for(key = key_defs; key->name != NULL; key++) {
                    cmd_completion(str, key->name);
                }
B
bellard 已提交
2989 2990
            }
            break;
B
bellard 已提交
2991 2992 2993 2994 2995 2996 2997 2998
        default:
            break;
        }
    }
    for(i = 0; i < nb_args; i++)
        qemu_free(args[i]);
}

2999
static int monitor_can_read(void *opaque)
B
bellard 已提交
3000
{
3001 3002 3003
    Monitor *mon = opaque;

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

3006
static void monitor_read(void *opaque, const uint8_t *buf, int size)
B
bellard 已提交
3007
{
3008
    Monitor *old_mon = cur_mon;
3009
    int i;
A
aliguori 已提交
3010

3011 3012
    cur_mon = opaque;

3013 3014 3015 3016 3017 3018 3019 3020 3021
    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 已提交
3022

3023 3024
    cur_mon = old_mon;
}
3025

A
aliguori 已提交
3026
static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
B
bellard 已提交
3027
{
3028
    monitor_suspend(mon);
A
aliguori 已提交
3029
    monitor_handle_command(mon, cmdline);
3030
    monitor_resume(mon);
3031 3032
}

3033
int monitor_suspend(Monitor *mon)
3034
{
3035 3036
    if (!mon->rs)
        return -ENOTTY;
3037
    mon->suspend_cnt++;
3038
    return 0;
3039 3040
}

A
aliguori 已提交
3041
void monitor_resume(Monitor *mon)
3042
{
3043 3044
    if (!mon->rs)
        return;
3045 3046
    if (--mon->suspend_cnt == 0)
        readline_show_prompt(mon->rs);
B
bellard 已提交
3047 3048
}

3049
static void monitor_event(void *opaque, int event)
3050
{
A
aliguori 已提交
3051 3052
    Monitor *mon = opaque;

3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065
    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;
3066

3067 3068 3069 3070 3071 3072 3073
    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;
    }
3074 3075
}

3076 3077 3078 3079 3080 3081 3082 3083 3084

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

3085
void monitor_init(CharDriverState *chr, int flags)
B
bellard 已提交
3086
{
3087
    static int is_first_init = 1;
3088
    Monitor *mon;
T
ths 已提交
3089 3090

    if (is_first_init) {
3091
        key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
T
ths 已提交
3092 3093
        is_first_init = 0;
    }
3094 3095

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

3097
    mon->chr = chr;
3098
    mon->flags = flags;
3099 3100
    if (mon->chr->focus != 0)
        mon->suspend_cnt = 1; /* mux'ed monitors start suspended */
3101 3102 3103 3104
    if (flags & MONITOR_USE_READLINE) {
        mon->rs = readline_init(mon, monitor_find_completion);
        monitor_read_command(mon, 0);
    }
3105

3106 3107
    qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event,
                          mon);
3108 3109

    LIST_INSERT_HEAD(&mon_list, mon, entry);
3110
    if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
3111
        cur_mon = mon;
B
bellard 已提交
3112 3113
}

A
aliguori 已提交
3114
static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
B
bellard 已提交
3115
{
3116 3117
    BlockDriverState *bs = opaque;
    int ret = 0;
B
bellard 已提交
3118

3119
    if (bdrv_set_key(bs, password) != 0) {
A
aliguori 已提交
3120
        monitor_printf(mon, "invalid password\n");
3121
        ret = -EPERM;
B
bellard 已提交
3122
    }
3123 3124
    if (mon->password_completion_cb)
        mon->password_completion_cb(mon->password_opaque, ret);
3125

3126
    monitor_read_command(mon, 1);
B
bellard 已提交
3127
}
3128

A
aliguori 已提交
3129
void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
3130 3131
                                 BlockDriverCompletionFunc *completion_cb,
                                 void *opaque)
3132
{
3133 3134
    int err;

3135 3136 3137 3138 3139
    if (!bdrv_key_required(bs)) {
        if (completion_cb)
            completion_cb(opaque, 0);
        return;
    }
3140

A
aliguori 已提交
3141 3142
    monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
                   bdrv_get_encrypted_filename(bs));
3143

3144 3145
    mon->password_completion_cb = completion_cb;
    mon->password_opaque = opaque;
3146

3147 3148 3149 3150
    err = monitor_read_password(mon, bdrv_password_cb, bs);

    if (err && completion_cb)
        completion_cb(opaque, err);
3151
}