monitor.c 88.0 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 CONFIG_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
}

1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
static void do_info_numa(Monitor *mon)
{
    int i, j;
    CPUState *env;

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

B
bellard 已提交
1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
#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 已提交
1441
static void do_info_profile(Monitor *mon)
B
bellard 已提交
1442 1443 1444 1445 1446
{
    int64_t total;
    total = qemu_time;
    if (total == 0)
        total = 1;
A
aliguori 已提交
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
    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 已提交
1460 1461 1462 1463 1464 1465 1466
    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;
1467
#ifdef CONFIG_KQEMU
B
bellard 已提交
1468 1469 1470 1471
    kqemu_record_dump();
#endif
}
#else
A
aliguori 已提交
1472
static void do_info_profile(Monitor *mon)
B
bellard 已提交
1473
{
A
aliguori 已提交
1474
    monitor_printf(mon, "Internal profiler not compiled\n");
B
bellard 已提交
1475 1476 1477
}
#endif

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

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

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

A
aliguori 已提交
1492
static void do_stop_capture(Monitor *mon, int n)
B
bellard 已提交
1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
{
    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 已提交
1508 1509 1510 1511
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 已提交
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521
{
    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 已提交
1522
        monitor_printf(mon, "Faied to add wave capture\n");
B
bellard 已提交
1523 1524 1525 1526 1527 1528
        qemu_free (s);
    }
    LIST_INSERT_HEAD (&capture_head, s, entries);
}
#endif

A
aurel32 已提交
1529
#if defined(TARGET_I386)
A
aliguori 已提交
1530
static void do_inject_nmi(Monitor *mon, int cpu_index)
A
aurel32 已提交
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
{
    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 已提交
1542
static void do_info_status(Monitor *mon)
A
aurel32 已提交
1543
{
1544 1545 1546 1547 1548 1549 1550
    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 已提交
1551
       monitor_printf(mon, "VM status: paused\n");
A
aurel32 已提交
1552 1553 1554
}


A
aliguori 已提交
1555
static void do_balloon(Monitor *mon, int value)
A
aliguori 已提交
1556 1557 1558 1559 1560
{
    ram_addr_t target = value;
    qemu_balloon(target << 20);
}

A
aliguori 已提交
1561
static void do_info_balloon(Monitor *mon)
A
aliguori 已提交
1562 1563 1564 1565
{
    ram_addr_t actual;

    actual = qemu_balloon_status();
A
aliguori 已提交
1566
    if (kvm_enabled() && !kvm_has_sync_mmu())
A
aliguori 已提交
1567 1568
        monitor_printf(mon, "Using KVM without synchronous MMU, "
                       "ballooning disabled\n");
A
aliguori 已提交
1569
    else if (actual == 0)
A
aliguori 已提交
1570
        monitor_printf(mon, "Ballooning not activated in VM\n");
A
aliguori 已提交
1571
    else
A
aliguori 已提交
1572
        monitor_printf(mon, "balloon: actual=%d\n", (int)(actual >> 20));
A
aliguori 已提交
1573 1574
}

1575 1576
static void do_acl(Monitor *mon,
                   const char *command,
1577 1578 1579 1580
                   const char *aclname,
                   const char *match,
                   int has_index,
                   int index)
1581 1582 1583 1584 1585
{
    qemu_acl *acl;

    acl = qemu_acl_find(aclname);
    if (!acl) {
1586 1587
        monitor_printf(mon, "acl: unknown list '%s'\n", aclname);
        return;
1588 1589 1590
    }

    if (strcmp(command, "show") == 0) {
1591 1592 1593
        int i = 0;
        qemu_acl_entry *entry;
        monitor_printf(mon, "policy: %s\n",
1594
                       acl->defaultDeny ? "deny" : "allow");
1595 1596 1597
        TAILQ_FOREACH(entry, &acl->entries, next) {
            i++;
            monitor_printf(mon, "%d: %s %s\n", i,
1598 1599
                           entry->deny ? "deny" : "allow",
                           entry->match);
1600
        }
1601
    } else if (strcmp(command, "reset") == 0) {
1602 1603
        qemu_acl_reset(acl);
        monitor_printf(mon, "acl: removed all rules\n");
1604
    } else if (strcmp(command, "policy") == 0) {
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
        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);
        }
1619
    } else if ((strcmp(command, "allow") == 0) ||
1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636
               (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);
1637
    } else if (strcmp(command, "remove") == 0) {
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649
        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);
1650
    } else {
1651
        monitor_printf(mon, "acl: unknown command '%s'\n", command);
1652 1653 1654
    }
}

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

1700 1701
    { "sendkey", "si?", do_sendkey,
      "keys [hold_ms]", "send keys to the VM (e.g. 'sendkey ctrl-alt-f1', default hold time=100 ms)" },
1702
    { "system_reset", "", do_system_reset,
B
bellard 已提交
1703
      "", "reset the system" },
1704
    { "system_powerdown", "", do_system_powerdown,
B
bellard 已提交
1705
      "", "send system power down event" },
1706
    { "sum", "ii", do_sum,
B
bellard 已提交
1707
      "addr size", "compute the checksum of a memory region" },
B
bellard 已提交
1708 1709 1710 1711
    { "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'" },
1712
    { "cpu", "i", do_cpu_set,
B
bellard 已提交
1713
      "index", "set the default CPU" },
1714
    { "mouse_move", "sss?", do_mouse_move,
B
bellard 已提交
1715
      "dx dy [dz]", "send mouse move events" },
1716
    { "mouse_button", "i", do_mouse_button,
B
bellard 已提交
1717
      "state", "change mouse button state (1=L, 2=M, 4=R)" },
1718 1719
    { "mouse_set", "i", do_mouse_set,
      "index", "set which mouse device receives events" },
B
bellard 已提交
1720 1721
#ifdef HAS_AUDIO
    { "wavcapture", "si?i?i?", do_wav_capture,
1722
      "path [frequency [bits [channels]]]",
B
bellard 已提交
1723 1724
      "capture audio to a wave file (default frequency=44100 bits=16 channels=2)" },
#endif
B
blueswir1 已提交
1725 1726
    { "stopcapture", "i", do_stop_capture,
      "capture index", "stop capture" },
1727
    { "memsave", "lis", do_memory_save,
B
bellard 已提交
1728
      "addr size file", "save to disk virtual memory dump starting at 'addr' of size 'size'", },
A
aurel32 已提交
1729 1730
    { "pmemsave", "lis", do_physical_memory_save,
      "addr size file", "save to disk physical memory dump starting at 'addr' of size 'size'", },
1731 1732
    { "boot_set", "s", do_boot_set,
      "bootdevice", "define new values for the boot device list" },
A
aurel32 已提交
1733 1734 1735 1736
#if defined(TARGET_I386)
    { "nmi", "i", do_inject_nmi,
      "cpu", "inject an NMI on the given CPU", },
#endif
A
aliguori 已提交
1737 1738 1739 1740 1741 1742
    { "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" },
1743 1744 1745 1746 1747 1748 1749 1750 1751
#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" },
1752
#endif
1753 1754
    { "host_net_add", "ss?", net_host_device_add,
      "tap|user|socket|vde|dump [options]", "add host VLAN client" },
1755 1756
    { "host_net_remove", "is", net_host_device_remove,
      "vlan_id name", "remove host VLAN client" },
1757 1758 1759 1760
#ifdef CONFIG_SLIRP
    { "host_net_redir", "s", net_slirp_redir,
      "[tcp|udp]:host-port:[guest-host]:guest-port", "redirect TCP or UDP connections from host to guest (requires -net user)" },
#endif
A
aliguori 已提交
1761 1762
    { "balloon", "i", do_balloon,
      "target", "request VM to change it's memory allocation (in MB)" },
1763
    { "set_link", "ss", do_set_link,
1764 1765
      "name up|down", "change the link status of a network adapter" },
    { "acl", "sss?i?", do_acl, "<command> <aclname> [<match> [<index>]]\n",
1766 1767 1768 1769 1770
                               "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" },
1771
    { NULL, NULL, },
B
bellard 已提交
1772 1773
};

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

1852 1853 1854 1855 1856
/*******************************************************************/

static const char *pch;
static jmp_buf expr_env;

B
bellard 已提交
1857 1858 1859
#define MD_TLONG 0
#define MD_I32   1

1860 1861 1862
typedef struct MonitorDef {
    const char *name;
    int offset;
B
blueswir1 已提交
1863
    target_long (*get_value)(const struct MonitorDef *md, int val);
B
bellard 已提交
1864
    int type;
1865 1866
} MonitorDef;

B
bellard 已提交
1867
#if defined(TARGET_I386)
B
blueswir1 已提交
1868
static target_long monitor_get_pc (const struct MonitorDef *md, int val)
B
bellard 已提交
1869
{
B
bellard 已提交
1870 1871 1872 1873
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return env->eip + env->segs[R_CS].base;
B
bellard 已提交
1874 1875 1876
}
#endif

1877
#if defined(TARGET_PPC)
B
blueswir1 已提交
1878
static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
1879
{
B
bellard 已提交
1880
    CPUState *env = mon_get_cpu();
1881 1882 1883
    unsigned int u;
    int i;

B
bellard 已提交
1884 1885 1886
    if (!env)
        return 0;

1887 1888
    u = 0;
    for (i = 0; i < 8; i++)
1889
        u |= env->crf[i] << (32 - (4 * i));
1890 1891 1892 1893

    return u;
}

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

B
blueswir1 已提交
1902
static target_long monitor_get_xer (const struct MonitorDef *md, int val)
1903
{
B
bellard 已提交
1904 1905 1906
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
A
aurel32 已提交
1907
    return env->xer;
1908
}
1909

B
blueswir1 已提交
1910
static target_long monitor_get_decr (const struct MonitorDef *md, int val)
1911
{
B
bellard 已提交
1912 1913 1914 1915
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_decr(env);
1916 1917
}

B
blueswir1 已提交
1918
static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
1919
{
B
bellard 已提交
1920 1921 1922 1923
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_tbu(env);
1924 1925
}

B
blueswir1 已提交
1926
static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
1927
{
B
bellard 已提交
1928 1929 1930 1931
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_tbl(env);
1932
}
1933 1934
#endif

1935
#if defined(TARGET_SPARC)
B
bellard 已提交
1936
#ifndef TARGET_SPARC64
B
blueswir1 已提交
1937
static target_long monitor_get_psr (const struct MonitorDef *md, int val)
1938
{
B
bellard 已提交
1939 1940 1941 1942
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return GET_PSR(env);
1943
}
B
bellard 已提交
1944
#endif
1945

B
blueswir1 已提交
1946
static target_long monitor_get_reg(const struct MonitorDef *md, int val)
1947
{
B
bellard 已提交
1948 1949 1950 1951
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return env->regwptr[val];
1952 1953 1954
}
#endif

B
blueswir1 已提交
1955
static const MonitorDef monitor_defs[] = {
1956
#ifdef TARGET_I386
B
bellard 已提交
1957 1958

#define SEG(name, seg) \
B
bellard 已提交
1959
    { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
B
bellard 已提交
1960
    { name ".base", offsetof(CPUState, segs[seg].base) },\
B
bellard 已提交
1961
    { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
B
bellard 已提交
1962

1963 1964 1965 1966 1967 1968 1969
    { "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 已提交
1970
    { "edi", offsetof(CPUState, regs[7]) },
B
bellard 已提交
1971 1972 1973 1974 1975 1976 1977 1978 1979 1980
#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
1981
    { "eflags", offsetof(CPUState, eflags) },
B
bellard 已提交
1982 1983 1984 1985
    { "eip", offsetof(CPUState, eip) },
    SEG("cs", R_CS)
    SEG("ds", R_DS)
    SEG("es", R_ES)
B
bellard 已提交
1986
    SEG("ss", R_SS)
B
bellard 已提交
1987 1988 1989
    SEG("fs", R_FS)
    SEG("gs", R_GS)
    { "pc", 0, monitor_get_pc, },
1990
#elif defined(TARGET_PPC)
J
j_mayer 已提交
1991
    /* General purpose registers */
1992 1993 1994 1995 1996 1997 1998 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
    { "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 已提交
2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058
    /* 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 已提交
2059
    { "nip|pc", offsetof(CPUState, nip) },
2060 2061
    { "lr", offsetof(CPUState, lr) },
    { "ctr", offsetof(CPUState, ctr) },
2062
    { "decr", 0, &monitor_get_decr, },
2063
    { "ccr", 0, &monitor_get_ccr, },
J
j_mayer 已提交
2064
    /* Machine state register */
2065 2066
    { "msr", 0, &monitor_get_msr, },
    { "xer", 0, &monitor_get_xer, },
2067 2068
    { "tbu", 0, &monitor_get_tbu, },
    { "tbl", 0, &monitor_get_tbl, },
J
j_mayer 已提交
2069 2070 2071 2072 2073
#if defined(TARGET_PPC64)
    /* Address space register */
    { "asr", offsetof(CPUState, asr) },
#endif
    /* Segment registers */
2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091
    { "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 ... */
2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127
#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 已提交
2128
#ifndef TARGET_SPARC64
2129 2130
    { "psr", 0, &monitor_get_psr, },
    { "wim", offsetof(CPUState, wim) },
B
bellard 已提交
2131
#endif
2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
    { "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 已提交
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191
#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
2192 2193 2194 2195
#endif
    { NULL },
};

A
aliguori 已提交
2196
static void expr_error(Monitor *mon, const char *msg)
B
bellard 已提交
2197
{
A
aliguori 已提交
2198
    monitor_printf(mon, "%s\n", msg);
2199 2200 2201
    longjmp(expr_env, 1);
}

B
bellard 已提交
2202
/* return 0 if OK, -1 if not found, -2 if no CPU defined */
B
bellard 已提交
2203
static int get_monitor_def(target_long *pval, const char *name)
2204
{
B
blueswir1 已提交
2205
    const MonitorDef *md;
B
bellard 已提交
2206 2207
    void *ptr;

2208 2209 2210
    for(md = monitor_defs; md->name != NULL; md++) {
        if (compare_cmd(name, md->name)) {
            if (md->get_value) {
2211
                *pval = md->get_value(md, md->offset);
2212
            } else {
B
bellard 已提交
2213 2214 2215 2216
                CPUState *env = mon_get_cpu();
                if (!env)
                    return -2;
                ptr = (uint8_t *)env + md->offset;
B
bellard 已提交
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227
                switch(md->type) {
                case MD_I32:
                    *pval = *(int32_t *)ptr;
                    break;
                case MD_TLONG:
                    *pval = *(target_long *)ptr;
                    break;
                default:
                    *pval = 0;
                    break;
                }
2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238
            }
            return 0;
        }
    }
    return -1;
}

static void next(void)
{
    if (pch != '\0') {
        pch++;
2239
        while (qemu_isspace(*pch))
2240 2241 2242 2243
            pch++;
    }
}

A
aliguori 已提交
2244
static int64_t expr_sum(Monitor *mon);
2245

A
aliguori 已提交
2246
static int64_t expr_unary(Monitor *mon)
2247
{
B
blueswir1 已提交
2248
    int64_t n;
2249
    char *p;
B
bellard 已提交
2250
    int ret;
2251 2252 2253 2254

    switch(*pch) {
    case '+':
        next();
A
aliguori 已提交
2255
        n = expr_unary(mon);
2256 2257 2258
        break;
    case '-':
        next();
A
aliguori 已提交
2259
        n = -expr_unary(mon);
2260 2261 2262
        break;
    case '~':
        next();
A
aliguori 已提交
2263
        n = ~expr_unary(mon);
2264 2265 2266
        break;
    case '(':
        next();
A
aliguori 已提交
2267
        n = expr_sum(mon);
2268
        if (*pch != ')') {
A
aliguori 已提交
2269
            expr_error(mon, "')' expected");
2270 2271 2272
        }
        next();
        break;
B
bellard 已提交
2273 2274 2275
    case '\'':
        pch++;
        if (*pch == '\0')
A
aliguori 已提交
2276
            expr_error(mon, "character constant expected");
B
bellard 已提交
2277 2278 2279
        n = *pch;
        pch++;
        if (*pch != '\'')
A
aliguori 已提交
2280
            expr_error(mon, "missing terminating \' character");
B
bellard 已提交
2281 2282
        next();
        break;
2283 2284 2285
    case '$':
        {
            char buf[128], *q;
2286
            target_long reg=0;
2287

2288 2289 2290 2291 2292
            pch++;
            q = buf;
            while ((*pch >= 'a' && *pch <= 'z') ||
                   (*pch >= 'A' && *pch <= 'Z') ||
                   (*pch >= '0' && *pch <= '9') ||
B
bellard 已提交
2293
                   *pch == '_' || *pch == '.') {
2294 2295 2296 2297
                if ((q - buf) < sizeof(buf) - 1)
                    *q++ = *pch;
                pch++;
            }
2298
            while (qemu_isspace(*pch))
2299 2300
                pch++;
            *q = 0;
2301
            ret = get_monitor_def(&reg, buf);
B
bellard 已提交
2302
            if (ret == -1)
A
aliguori 已提交
2303
                expr_error(mon, "unknown register");
2304
            else if (ret == -2)
A
aliguori 已提交
2305
                expr_error(mon, "no cpu defined");
2306
            n = reg;
2307 2308 2309
        }
        break;
    case '\0':
A
aliguori 已提交
2310
        expr_error(mon, "unexpected end of expression");
2311 2312 2313
        n = 0;
        break;
    default:
2314
#if TARGET_PHYS_ADDR_BITS > 32
B
bellard 已提交
2315 2316
        n = strtoull(pch, &p, 0);
#else
2317
        n = strtoul(pch, &p, 0);
B
bellard 已提交
2318
#endif
2319
        if (pch == p) {
A
aliguori 已提交
2320
            expr_error(mon, "invalid char in expression");
2321 2322
        }
        pch = p;
2323
        while (qemu_isspace(*pch))
2324 2325 2326 2327 2328 2329 2330
            pch++;
        break;
    }
    return n;
}


A
aliguori 已提交
2331
static int64_t expr_prod(Monitor *mon)
2332
{
B
blueswir1 已提交
2333
    int64_t val, val2;
B
bellard 已提交
2334
    int op;
2335

A
aliguori 已提交
2336
    val = expr_unary(mon);
2337 2338 2339 2340 2341
    for(;;) {
        op = *pch;
        if (op != '*' && op != '/' && op != '%')
            break;
        next();
A
aliguori 已提交
2342
        val2 = expr_unary(mon);
2343 2344 2345 2346 2347 2348 2349
        switch(op) {
        default:
        case '*':
            val *= val2;
            break;
        case '/':
        case '%':
2350
            if (val2 == 0)
A
aliguori 已提交
2351
                expr_error(mon, "division by zero");
2352 2353 2354 2355 2356 2357 2358 2359 2360 2361
            if (op == '/')
                val /= val2;
            else
                val %= val2;
            break;
        }
    }
    return val;
}

A
aliguori 已提交
2362
static int64_t expr_logic(Monitor *mon)
2363
{
B
blueswir1 已提交
2364
    int64_t val, val2;
B
bellard 已提交
2365
    int op;
2366

A
aliguori 已提交
2367
    val = expr_prod(mon);
2368 2369 2370 2371 2372
    for(;;) {
        op = *pch;
        if (op != '&' && op != '|' && op != '^')
            break;
        next();
A
aliguori 已提交
2373
        val2 = expr_prod(mon);
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389
        switch(op) {
        default:
        case '&':
            val &= val2;
            break;
        case '|':
            val |= val2;
            break;
        case '^':
            val ^= val2;
            break;
        }
    }
    return val;
}

A
aliguori 已提交
2390
static int64_t expr_sum(Monitor *mon)
2391
{
B
blueswir1 已提交
2392
    int64_t val, val2;
B
bellard 已提交
2393
    int op;
2394

A
aliguori 已提交
2395
    val = expr_logic(mon);
2396 2397 2398 2399 2400
    for(;;) {
        op = *pch;
        if (op != '+' && op != '-')
            break;
        next();
A
aliguori 已提交
2401
        val2 = expr_logic(mon);
2402 2403 2404 2405 2406 2407 2408 2409
        if (op == '+')
            val += val2;
        else
            val -= val2;
    }
    return val;
}

A
aliguori 已提交
2410
static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2411 2412 2413 2414 2415 2416
{
    pch = *pp;
    if (setjmp(expr_env)) {
        *pp = pch;
        return -1;
    }
2417
    while (qemu_isspace(*pch))
2418
        pch++;
A
aliguori 已提交
2419
    *pval = expr_sum(mon);
2420 2421 2422 2423 2424 2425 2426 2427 2428 2429
    *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 已提交
2430
    q = buf;
2431
    p = *pp;
2432
    while (qemu_isspace(*p))
2433 2434 2435
        p++;
    if (*p == '\0') {
    fail:
B
bellard 已提交
2436
        *q = '\0';
2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
        *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 已提交
2472
            qemu_printf("unterminated string\n");
2473 2474 2475 2476
            goto fail;
        }
        p++;
    } else {
2477
        while (*p != '\0' && !qemu_isspace(*p)) {
2478 2479 2480 2481 2482 2483
            if ((q - buf) < buf_size - 1) {
                *q++ = *p;
            }
            p++;
        }
    }
B
bellard 已提交
2484
    *q = '\0';
2485 2486 2487 2488 2489 2490 2491 2492 2493
    *pp = p;
    return 0;
}

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

#define MAX_ARGS 16

A
aliguori 已提交
2494
static void monitor_handle_command(Monitor *mon, const char *cmdline)
2495 2496 2497 2498
{
    const char *p, *pstart, *typestr;
    char *q;
    int c, nb_args, len, i, has_arg;
A
aliguori 已提交
2499
    const mon_cmd_t *cmd;
2500 2501 2502 2503
    char cmdname[256];
    char buf[1024];
    void *str_allocated[MAX_ARGS];
    void *args[MAX_ARGS];
A
aliguori 已提交
2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515
    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 已提交
2516 2517

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

2521
    /* extract the command name */
B
bellard 已提交
2522
    p = cmdline;
2523
    q = cmdname;
2524
    while (qemu_isspace(*p))
2525 2526 2527 2528
        p++;
    if (*p == '\0')
        return;
    pstart = p;
2529
    while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2530 2531 2532 2533 2534 2535
        p++;
    len = p - pstart;
    if (len > sizeof(cmdname) - 1)
        len = sizeof(cmdname) - 1;
    memcpy(cmdname, pstart, len);
    cmdname[len] = '\0';
2536

2537
    /* find the command */
A
aliguori 已提交
2538
    for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
2539
        if (compare_cmd(cmdname, cmd->name))
2540 2541
            goto found;
    }
A
aliguori 已提交
2542
    monitor_printf(mon, "unknown command: '%s'\n", cmdname);
2543 2544 2545 2546 2547
    return;
 found:

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

2549 2550 2551
    /* parse the parameters */
    typestr = cmd->args_type;
    nb_args = 0;
B
bellard 已提交
2552
    for(;;) {
2553 2554
        c = *typestr;
        if (c == '\0')
B
bellard 已提交
2555
            break;
2556 2557 2558
        typestr++;
        switch(c) {
        case 'F':
B
bellard 已提交
2559
        case 'B':
2560 2561 2562 2563
        case 's':
            {
                int ret;
                char *str;
2564

2565
                while (qemu_isspace(*p))
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576
                    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 已提交
2577 2578
                    switch(c) {
                    case 'F':
A
aliguori 已提交
2579 2580
                        monitor_printf(mon, "%s: filename expected\n",
                                       cmdname);
B
bellard 已提交
2581 2582
                        break;
                    case 'B':
A
aliguori 已提交
2583 2584
                        monitor_printf(mon, "%s: block device name expected\n",
                                       cmdname);
B
bellard 已提交
2585 2586
                        break;
                    default:
A
aliguori 已提交
2587
                        monitor_printf(mon, "%s: string expected\n", cmdname);
B
bellard 已提交
2588 2589
                        break;
                    }
2590 2591 2592
                    goto fail;
                }
                str = qemu_malloc(strlen(buf) + 1);
B
blueswir1 已提交
2593
                pstrcpy(str, sizeof(buf), buf);
2594 2595 2596 2597
                str_allocated[nb_args] = str;
            add_str:
                if (nb_args >= MAX_ARGS) {
                error_args:
A
aliguori 已提交
2598
                    monitor_printf(mon, "%s: too many arguments\n", cmdname);
2599 2600 2601 2602
                    goto fail;
                }
                args[nb_args++] = str;
            }
B
bellard 已提交
2603
            break;
2604 2605 2606
        case '/':
            {
                int count, format, size;
2607

2608
                while (qemu_isspace(*p))
2609 2610 2611 2612 2613
                    p++;
                if (*p == '/') {
                    /* format found */
                    p++;
                    count = 1;
2614
                    if (qemu_isdigit(*p)) {
2615
                        count = 0;
2616
                        while (qemu_isdigit(*p)) {
2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654
                            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:
2655
                    if (*p != '\0' && !qemu_isspace(*p)) {
A
aliguori 已提交
2656 2657
                        monitor_printf(mon, "invalid char in format: '%c'\n",
                                       *p);
2658 2659 2660 2661
                        goto fail;
                    }
                    if (format < 0)
                        format = default_fmt_format;
2662 2663 2664 2665
                    if (format != 'i') {
                        /* for 'i', not specifying a size gives -1 as size */
                        if (size < 0)
                            size = default_fmt_size;
A
aurel32 已提交
2666
                        default_fmt_size = size;
2667
                    }
2668 2669 2670 2671
                    default_fmt_format = format;
                } else {
                    count = 1;
                    format = default_fmt_format;
2672 2673 2674 2675 2676
                    if (format != 'i') {
                        size = default_fmt_size;
                    } else {
                        size = -1;
                    }
2677 2678 2679
                }
                if (nb_args + 3 > MAX_ARGS)
                    goto error_args;
J
j_mayer 已提交
2680 2681 2682
                args[nb_args++] = (void*)(long)count;
                args[nb_args++] = (void*)(long)format;
                args[nb_args++] = (void*)(long)size;
2683
            }
B
bellard 已提交
2684
            break;
2685
        case 'i':
B
bellard 已提交
2686
        case 'l':
2687
            {
B
blueswir1 已提交
2688
                int64_t val;
2689

2690
                while (qemu_isspace(*p))
2691
                    p++;
B
bellard 已提交
2692 2693 2694 2695 2696 2697 2698 2699 2700
                if (*typestr == '?' || *typestr == '.') {
                    if (*typestr == '?') {
                        if (*p == '\0')
                            has_arg = 0;
                        else
                            has_arg = 1;
                    } else {
                        if (*p == '.') {
                            p++;
2701
                            while (qemu_isspace(*p))
B
bellard 已提交
2702 2703 2704 2705 2706 2707
                                p++;
                            has_arg = 1;
                        } else {
                            has_arg = 0;
                        }
                    }
B
bellard 已提交
2708
                    typestr++;
2709 2710
                    if (nb_args >= MAX_ARGS)
                        goto error_args;
J
j_mayer 已提交
2711
                    args[nb_args++] = (void *)(long)has_arg;
2712 2713 2714 2715 2716 2717 2718
                    if (!has_arg) {
                        if (nb_args >= MAX_ARGS)
                            goto error_args;
                        val = -1;
                        goto add_num;
                    }
                }
A
aliguori 已提交
2719
                if (get_expr(mon, &val, &p))
2720 2721
                    goto fail;
            add_num:
B
bellard 已提交
2722 2723 2724
                if (c == 'i') {
                    if (nb_args >= MAX_ARGS)
                        goto error_args;
J
j_mayer 已提交
2725
                    args[nb_args++] = (void *)(long)val;
B
bellard 已提交
2726 2727 2728
                } else {
                    if ((nb_args + 1) >= MAX_ARGS)
                        goto error_args;
2729
#if TARGET_PHYS_ADDR_BITS > 32
J
j_mayer 已提交
2730
                    args[nb_args++] = (void *)(long)((val >> 32) & 0xffffffff);
B
bellard 已提交
2731 2732 2733
#else
                    args[nb_args++] = (void *)0;
#endif
J
j_mayer 已提交
2734
                    args[nb_args++] = (void *)(long)(val & 0xffffffff);
B
bellard 已提交
2735
                }
2736 2737 2738 2739 2740 2741
            }
            break;
        case '-':
            {
                int has_option;
                /* option */
2742

2743 2744 2745
                c = *typestr++;
                if (c == '\0')
                    goto bad_type;
2746
                while (qemu_isspace(*p))
2747 2748 2749 2750 2751
                    p++;
                has_option = 0;
                if (*p == '-') {
                    p++;
                    if (*p != c) {
A
aliguori 已提交
2752 2753
                        monitor_printf(mon, "%s: unsupported option -%c\n",
                                       cmdname, *p);
2754 2755 2756 2757 2758 2759 2760
                        goto fail;
                    }
                    p++;
                    has_option = 1;
                }
                if (nb_args >= MAX_ARGS)
                    goto error_args;
J
j_mayer 已提交
2761
                args[nb_args++] = (void *)(long)has_option;
2762 2763 2764 2765
            }
            break;
        default:
        bad_type:
A
aliguori 已提交
2766
            monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
2767 2768
            goto fail;
        }
B
bellard 已提交
2769
    }
2770
    /* check that all arguments were parsed */
2771
    while (qemu_isspace(*p))
2772 2773
        p++;
    if (*p != '\0') {
A
aliguori 已提交
2774 2775
        monitor_printf(mon, "%s: extraneous characters at the end of line\n",
                       cmdname);
2776
        goto fail;
B
bellard 已提交
2777
    }
2778 2779 2780

    switch(nb_args) {
    case 0:
2781
        handler_0 = cmd->handler;
A
aliguori 已提交
2782
        handler_0(mon);
2783 2784
        break;
    case 1:
2785
        handler_1 = cmd->handler;
A
aliguori 已提交
2786
        handler_1(mon, args[0]);
2787 2788
        break;
    case 2:
2789
        handler_2 = cmd->handler;
A
aliguori 已提交
2790
        handler_2(mon, args[0], args[1]);
2791 2792
        break;
    case 3:
2793
        handler_3 = cmd->handler;
A
aliguori 已提交
2794
        handler_3(mon, args[0], args[1], args[2]);
2795 2796
        break;
    case 4:
2797
        handler_4 = cmd->handler;
A
aliguori 已提交
2798
        handler_4(mon, args[0], args[1], args[2], args[3]);
2799 2800
        break;
    case 5:
2801
        handler_5 = cmd->handler;
A
aliguori 已提交
2802
        handler_5(mon, args[0], args[1], args[2], args[3], args[4]);
2803
        break;
B
bellard 已提交
2804
    case 6:
2805
        handler_6 = cmd->handler;
A
aliguori 已提交
2806
        handler_6(mon, args[0], args[1], args[2], args[3], args[4], args[5]);
B
bellard 已提交
2807
        break;
B
bellard 已提交
2808
    case 7:
2809
        handler_7 = cmd->handler;
A
aliguori 已提交
2810 2811
        handler_7(mon, args[0], args[1], args[2], args[3], args[4], args[5],
                  args[6]);
B
bellard 已提交
2812
        break;
2813
    default:
A
aliguori 已提交
2814
        monitor_printf(mon, "unsupported number of arguments: %d\n", nb_args);
2815
        goto fail;
B
bellard 已提交
2816
    }
2817 2818 2819
 fail:
    for(i = 0; i < MAX_ARGS; i++)
        qemu_free(str_allocated[i]);
B
bellard 已提交
2820 2821 2822
    return;
}

B
bellard 已提交
2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840
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))) {
2841
            readline_add_completion(cur_mon->rs, cmd);
B
bellard 已提交
2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857
        }
        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;

2858
    p = strrchr(input, '/');
B
bellard 已提交
2859 2860 2861
    if (!p) {
        input_path_len = 0;
        pstrcpy(file_prefix, sizeof(file_prefix), input);
B
blueswir1 已提交
2862
        pstrcpy(path, sizeof(path), ".");
B
bellard 已提交
2863 2864 2865 2866 2867 2868 2869 2870 2871
    } 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 已提交
2872 2873
    monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
                   input, path, file_prefix);
B
bellard 已提交
2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884
#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 已提交
2885 2886 2887
            if (input_path_len < sizeof(file))
                pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
                        d->d_name);
B
bellard 已提交
2888 2889 2890 2891 2892
            /* 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 已提交
2893
                pstrcat(file, sizeof(file), "/");
2894
            readline_add_completion(cur_mon->rs, file);
B
bellard 已提交
2895 2896 2897 2898 2899
        }
    }
    closedir(ffs);
}

2900
static void block_completion_it(void *opaque, BlockDriverState *bs)
B
bellard 已提交
2901
{
2902
    const char *name = bdrv_get_device_name(bs);
B
bellard 已提交
2903 2904 2905 2906
    const char *input = opaque;

    if (input[0] == '\0' ||
        !strncmp(name, (char *)input, strlen(input))) {
2907
        readline_add_completion(cur_mon->rs, name);
B
bellard 已提交
2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921
    }
}

/* 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(;;) {
2922
        while (qemu_isspace(*p))
B
bellard 已提交
2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936
            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;
}

2937
static void monitor_find_completion(const char *cmdline)
B
bellard 已提交
2938 2939 2940 2941 2942
{
    const char *cmdname;
    char *args[MAX_ARGS];
    int nb_args, i, len;
    const char *ptype, *str;
A
aliguori 已提交
2943
    const mon_cmd_t *cmd;
2944
    const KeyDef *key;
B
bellard 已提交
2945 2946 2947 2948

    parse_cmdline(cmdline, &nb_args, args);
#ifdef DEBUG_COMPLETION
    for(i = 0; i < nb_args; i++) {
A
aliguori 已提交
2949
        monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
B
bellard 已提交
2950 2951 2952 2953 2954 2955
    }
#endif

    /* if the line ends with a space, it means we want to complete the
       next arg */
    len = strlen(cmdline);
2956
    if (len > 0 && qemu_isspace(cmdline[len - 1])) {
B
bellard 已提交
2957 2958 2959 2960 2961 2962 2963 2964 2965 2966
        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];
2967
        readline_set_completion_index(cur_mon->rs, strlen(cmdname));
A
aliguori 已提交
2968
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
B
bellard 已提交
2969 2970 2971 2972
            cmd_completion(cmdname, cmd->name);
        }
    } else {
        /* find the command */
A
aliguori 已提交
2973
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
B
bellard 已提交
2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990
            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 */
2991
            readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
2992 2993 2994 2995
            file_completion(str);
            break;
        case 'B':
            /* block device name completion */
2996
            readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
2997 2998
            bdrv_iterate(block_completion_it, (void *)str);
            break;
B
bellard 已提交
2999 3000 3001
        case 's':
            /* XXX: more generic ? */
            if (!strcmp(cmd->name, "info")) {
3002
                readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
3003 3004 3005
                for(cmd = info_cmds; cmd->name != NULL; cmd++) {
                    cmd_completion(str, cmd->name);
                }
3006
            } else if (!strcmp(cmd->name, "sendkey")) {
B
blueswir1 已提交
3007 3008 3009
                char *sep = strrchr(str, '-');
                if (sep)
                    str = sep + 1;
3010
                readline_set_completion_index(cur_mon->rs, strlen(str));
3011 3012 3013
                for(key = key_defs; key->name != NULL; key++) {
                    cmd_completion(str, key->name);
                }
B
bellard 已提交
3014 3015
            }
            break;
B
bellard 已提交
3016 3017 3018 3019 3020 3021 3022 3023
        default:
            break;
        }
    }
    for(i = 0; i < nb_args; i++)
        qemu_free(args[i]);
}

3024
static int monitor_can_read(void *opaque)
B
bellard 已提交
3025
{
3026 3027 3028
    Monitor *mon = opaque;

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

3031
static void monitor_read(void *opaque, const uint8_t *buf, int size)
B
bellard 已提交
3032
{
3033
    Monitor *old_mon = cur_mon;
3034
    int i;
A
aliguori 已提交
3035

3036 3037
    cur_mon = opaque;

3038 3039 3040 3041 3042 3043 3044 3045 3046
    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 已提交
3047

3048 3049
    cur_mon = old_mon;
}
3050

A
aliguori 已提交
3051
static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
B
bellard 已提交
3052
{
3053
    monitor_suspend(mon);
A
aliguori 已提交
3054
    monitor_handle_command(mon, cmdline);
3055
    monitor_resume(mon);
3056 3057
}

3058
int monitor_suspend(Monitor *mon)
3059
{
3060 3061
    if (!mon->rs)
        return -ENOTTY;
3062
    mon->suspend_cnt++;
3063
    return 0;
3064 3065
}

A
aliguori 已提交
3066
void monitor_resume(Monitor *mon)
3067
{
3068 3069
    if (!mon->rs)
        return;
3070 3071
    if (--mon->suspend_cnt == 0)
        readline_show_prompt(mon->rs);
B
bellard 已提交
3072 3073
}

3074
static void monitor_event(void *opaque, int event)
3075
{
A
aliguori 已提交
3076 3077
    Monitor *mon = opaque;

3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090
    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;
3091

3092 3093 3094 3095 3096 3097 3098
    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;
    }
3099 3100
}

3101 3102 3103 3104 3105 3106 3107 3108 3109

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

3110
void monitor_init(CharDriverState *chr, int flags)
B
bellard 已提交
3111
{
3112
    static int is_first_init = 1;
3113
    Monitor *mon;
T
ths 已提交
3114 3115

    if (is_first_init) {
3116
        key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
T
ths 已提交
3117 3118
        is_first_init = 0;
    }
3119 3120

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

3122
    mon->chr = chr;
3123
    mon->flags = flags;
3124 3125
    if (mon->chr->focus != 0)
        mon->suspend_cnt = 1; /* mux'ed monitors start suspended */
3126 3127 3128 3129
    if (flags & MONITOR_USE_READLINE) {
        mon->rs = readline_init(mon, monitor_find_completion);
        monitor_read_command(mon, 0);
    }
3130

3131 3132
    qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event,
                          mon);
3133 3134

    LIST_INSERT_HEAD(&mon_list, mon, entry);
3135
    if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
3136
        cur_mon = mon;
B
bellard 已提交
3137 3138
}

A
aliguori 已提交
3139
static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
B
bellard 已提交
3140
{
3141 3142
    BlockDriverState *bs = opaque;
    int ret = 0;
B
bellard 已提交
3143

3144
    if (bdrv_set_key(bs, password) != 0) {
A
aliguori 已提交
3145
        monitor_printf(mon, "invalid password\n");
3146
        ret = -EPERM;
B
bellard 已提交
3147
    }
3148 3149
    if (mon->password_completion_cb)
        mon->password_completion_cb(mon->password_opaque, ret);
3150

3151
    monitor_read_command(mon, 1);
B
bellard 已提交
3152
}
3153

A
aliguori 已提交
3154
void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
3155 3156
                                 BlockDriverCompletionFunc *completion_cb,
                                 void *opaque)
3157
{
3158 3159
    int err;

3160 3161 3162 3163 3164
    if (!bdrv_key_required(bs)) {
        if (completion_cb)
            completion_cb(opaque, 0);
        return;
    }
3165

A
aliguori 已提交
3166 3167
    monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
                   bdrv_get_encrypted_filename(bs));
3168

3169 3170
    mon->password_completion_cb = completion_cb;
    mon->password_opaque = opaque;
3171

3172 3173 3174 3175
    err = monitor_read_password(mon, bdrv_password_cb, bs);

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