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

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

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

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

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

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

static LIST_HEAD(mon_list, Monitor) mon_list;
99

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

103
Monitor *cur_mon = NULL;
A
aliguori 已提交
104

105 106
static void monitor_command_cb(Monitor *mon, const char *cmdline,
                               void *opaque);
107

108 109 110 111 112 113
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 已提交
114

115 116
static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
                                 void *opaque)
117
{
118 119 120 121 122 123 124 125
    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;
    }
126 127
}

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

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

    if (!mon)
        return;

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

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

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

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

    for (i = 0; filename[i]; i++) {
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
        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;
        }
196 197 198
    }
}

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

B
bellard 已提交
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
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 已提交
228 229
static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
                          const char *prefix, const char *name)
B
bellard 已提交
230
{
A
aliguori 已提交
231
    const mon_cmd_t *cmd;
B
bellard 已提交
232 233 234

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

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

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

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

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

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

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

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

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

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

A
aliguori 已提交
316
static void do_info_uuid(Monitor *mon)
317
{
A
aliguori 已提交
318 319 320 321 322
    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]);
323 324
}

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

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

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

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

A
aliguori 已提交
363
static void do_info_cpus(Monitor *mon)
B
bellard 已提交
364 365 366 367 368 369 370
{
    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) {
371
        cpu_synchronize_state(env);
A
aliguori 已提交
372
        monitor_printf(mon, "%c CPU #%d:",
373
                       (env == mon->mon_cpu) ? '*' : ' ',
A
aliguori 已提交
374
                       env->cpu_index);
B
bellard 已提交
375
#if defined(TARGET_I386)
A
aliguori 已提交
376 377
        monitor_printf(mon, " pc=0x" TARGET_FMT_lx,
                       env->eip + env->segs[R_CS].base);
B
bellard 已提交
378
#elif defined(TARGET_PPC)
A
aliguori 已提交
379
        monitor_printf(mon, " nip=0x" TARGET_FMT_lx, env->nip);
B
bellard 已提交
380
#elif defined(TARGET_SPARC)
A
aliguori 已提交
381 382
        monitor_printf(mon, " pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx,
                       env->pc, env->npc);
383
#elif defined(TARGET_MIPS)
A
aliguori 已提交
384
        monitor_printf(mon, " PC=0x" TARGET_FMT_lx, env->active_tc.PC);
B
bellard 已提交
385
#endif
386
        if (env->halted)
A
aliguori 已提交
387 388
            monitor_printf(mon, " (halted)");
        monitor_printf(mon, "\n");
B
bellard 已提交
389 390 391
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

499
    monitor_read_command(mon, 1);
B
bellard 已提交
500 501
}

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

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

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

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

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

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

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

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

576
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
577

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

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

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

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

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

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

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

613
static void do_gdbserver(Monitor *mon, const QDict *qdict)
614
{
615
    const char *device = qdict_get_try_str(qdict, "device");
616 617 618 619 620 621
    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) {
622
        monitor_printf(mon, "Disabled gdbserver\n");
623
    } else {
624 625
        monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
                       device);
626 627 628
    }
}

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

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

A
aliguori 已提交
664
static void memory_dump(Monitor *mon, int count, int format, int wsize,
665
                        target_phys_addr_t addr, int is_physical)
666
{
B
bellard 已提交
667
    CPUState *env;
668 669 670 671 672 673 674
    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 已提交
675 676 677
        env = mon_get_cpu();
        if (!env && !is_physical)
            return;
678
#ifdef TARGET_I386
679
        if (wsize == 2) {
680
            flags = 1;
681 682 683
        } else if (wsize == 4) {
            flags = 0;
        } else {
B
bellard 已提交
684
            /* as default we use the current CS size */
685
            flags = 0;
B
bellard 已提交
686 687
            if (env) {
#ifdef TARGET_X86_64
688
                if ((env->efer & MSR_EFER_LMA) &&
B
bellard 已提交
689 690 691 692 693 694 695
                    (env->segs[R_CS].flags & DESC_L_MASK))
                    flags = 2;
                else
#endif
                if (!(env->segs[R_CS].flags & DESC_B_MASK))
                    flags = 1;
            }
696 697
        }
#endif
A
aliguori 已提交
698
        monitor_disas(mon, env, addr, count, is_physical, flags);
699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
        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) {
728
        if (is_physical)
A
aliguori 已提交
729
            monitor_printf(mon, TARGET_FMT_plx ":", addr);
730
        else
A
aliguori 已提交
731
            monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
732 733 734 735 736 737
        l = len;
        if (l > line_size)
            l = line_size;
        if (is_physical) {
            cpu_physical_memory_rw(addr, buf, l, 0);
        } else {
B
bellard 已提交
738 739 740
            env = mon_get_cpu();
            if (!env)
                break;
741
            if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
A
aliguori 已提交
742
                monitor_printf(mon, " Cannot access memory\n");
743 744
                break;
            }
745
        }
746
        i = 0;
747 748 749 750 751 752 753 754 755 756
        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 已提交
757
                v = (uint32_t)ldl_raw(buf + i);
758 759 760 761 762
                break;
            case 8:
                v = ldq_raw(buf + i);
                break;
            }
A
aliguori 已提交
763
            monitor_printf(mon, " ");
764 765
            switch(format) {
            case 'o':
A
aliguori 已提交
766
                monitor_printf(mon, "%#*" PRIo64, max_digits, v);
767 768
                break;
            case 'x':
A
aliguori 已提交
769
                monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
770 771
                break;
            case 'u':
A
aliguori 已提交
772
                monitor_printf(mon, "%*" PRIu64, max_digits, v);
773 774
                break;
            case 'd':
A
aliguori 已提交
775
                monitor_printf(mon, "%*" PRId64, max_digits, v);
776 777
                break;
            case 'c':
A
aliguori 已提交
778
                monitor_printc(mon, v);
779 780 781 782
                break;
            }
            i += wsize;
        }
A
aliguori 已提交
783
        monitor_printf(mon, "\n");
784 785 786 787 788
        addr += l;
        len -= l;
    }
}

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

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

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

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

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

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

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

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

    f = fopen(filename, "wb");
    if (!f) {
A
aliguori 已提交
872
        monitor_printf(mon, "could not open '%s'\n", filename);
B
bellard 已提交
873 874 875 876 877 878 879 880 881 882 883 884 885 886
        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);
}

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

    f = fopen(filename, "wb");
    if (!f) {
A
aliguori 已提交
898
        monitor_printf(mon, "could not open '%s'\n", filename);
A
aurel32 已提交
899 900 901 902 903 904 905 906 907 908 909 910 911 912 913
        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);
}

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

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

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

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

B
bellard 已提交
941 942
    { 0x38, "alt" },
    { 0xb8, "alt_r" },
943 944
    { 0x64, "altgr" },
    { 0xe4, "altgr_r" },
B
bellard 已提交
945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961
    { 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" },
962 963
    { 0x0c, "minus" },
    { 0x0d, "equal" },
B
bellard 已提交
964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996
    { 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" },
997 998 999
    { 0x33, "comma" },
    { 0x34, "dot" },
    { 0x35, "slash" },
1000

B
balrog 已提交
1001 1002
    { 0x37, "asterisk" },

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

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

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

B
bellard 已提交
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
    { 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" },
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
#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 已提交
1073 1074 1075 1076 1077 1078
    { 0, NULL },
};

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

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

1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
#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);
    }
}

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

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

B
bellard 已提交
1166 1167
static int mouse_button_state;

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

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

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

    if (has_index) {
1198
        int index = qdict_get_int(qdict, "index");
1199
        cpu_outb(NULL, addr & IOPORTS_MASK, index & 0xff);
B
bellard 已提交
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
        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 已提交
1219 1220
    monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
                   suffix, addr, size * 2, val);
B
bellard 已提交
1221
}
B
bellard 已提交
1222

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

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

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

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

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

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

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

B
bellard 已提交
1271
#if defined(TARGET_I386)
A
aliguori 已提交
1272
static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
B
bellard 已提交
1273
{
A
aliguori 已提交
1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
    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 已提交
1285 1286
}

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

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

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

A
aliguori 已提交
1324
static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
B
bellard 已提交
1325 1326
                      uint32_t end, int prot)
{
B
bellard 已提交
1327 1328 1329
    int prot1;
    prot1 = *plast_prot;
    if (prot != prot1) {
B
bellard 已提交
1330
        if (*pstart != -1) {
A
aliguori 已提交
1331 1332 1333 1334 1335
            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 已提交
1336 1337 1338 1339 1340 1341 1342 1343 1344
        }
        if (prot != 0)
            *pstart = end;
        else
            *pstart = -1;
        *plast_prot = prot;
    }
}

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

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

B
bellard 已提交
1355
    if (!(env->cr[0] & CR0_PG_MASK)) {
A
aliguori 已提交
1356
        monitor_printf(mon, "PG disabled\n");
B
bellard 已提交
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368
        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 已提交
1369
                mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1370 1371
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1372
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
B
bellard 已提交
1373 1374 1375 1376 1377 1378 1379 1380
                                             (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 已提交
1381
                    mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1382 1383 1384 1385
                }
            }
        } else {
            prot = 0;
A
aliguori 已提交
1386
            mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1387 1388 1389 1390 1391
        }
    }
}
#endif

A
aurel32 已提交
1392 1393
#if defined(TARGET_SH4)

A
aliguori 已提交
1394
static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
A
aurel32 已提交
1395
{
A
aliguori 已提交
1396 1397 1398 1399 1400 1401 1402 1403
    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 已提交
1404 1405
}

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

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

#endif

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

1434 1435
static void do_info_numa(Monitor *mon)
{
1436
    int i;
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
    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 已提交
1453 1454
#ifdef CONFIG_PROFILER

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

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

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

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

1489
#ifdef HAS_AUDIO
1490
static void do_stop_capture(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1491 1492
{
    int i;
1493
    int n = qdict_get_int(qdict, "n");
B
bellard 已提交
1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505
    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;
        }
    }
}

1506 1507 1508 1509 1510 1511 1512 1513 1514
static void do_wav_capture(Monitor *mon, const QDict *qdict)
{
    const char *path = qdict_get_str(qdict, "path");
    int has_freq = qdict_haskey(qdict, "freq");
    int freq = qdict_get_try_int(qdict, "freq", -1);
    int has_bits = qdict_haskey(qdict, "bits");
    int bits = qdict_get_try_int(qdict, "bits", -1);
    int has_channels = qdict_haskey(qdict, "nchannels");
    int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
B
bellard 已提交
1515 1516 1517 1518 1519 1520 1521 1522 1523
    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 已提交
1524
        monitor_printf(mon, "Faied to add wave capture\n");
B
bellard 已提交
1525 1526 1527 1528 1529 1530
        qemu_free (s);
    }
    LIST_INSERT_HEAD (&capture_head, s, entries);
}
#endif

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

    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 已提交
1545
static void do_info_status(Monitor *mon)
A
aurel32 已提交
1546
{
1547 1548 1549 1550 1551 1552 1553
    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 已提交
1554
       monitor_printf(mon, "VM status: paused\n");
A
aurel32 已提交
1555 1556 1557
}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

J
Jan Kiszka 已提交
1676
    if (acl) {
1677 1678 1679 1680 1681
        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);
1682 1683 1684
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    vm_stop(0);

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

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

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

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

        fd = monfd->fd;

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

        return fd;
    }

    return -1;
}

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

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

1886 1887 1888 1889 1890
/*******************************************************************/

static const char *pch;
static jmp_buf expr_env;

B
bellard 已提交
1891 1892 1893
#define MD_TLONG 0
#define MD_I32   1

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

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

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

B
bellard 已提交
1918 1919 1920
    if (!env)
        return 0;

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

    return u;
}

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

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

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

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

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

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

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

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

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

1997 1998 1999 2000 2001 2002 2003
    { "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 已提交
2004
    { "edi", offsetof(CPUState, regs[7]) },
B
bellard 已提交
2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
#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
2015
    { "eflags", offsetof(CPUState, eflags) },
B
bellard 已提交
2016 2017 2018 2019
    { "eip", offsetof(CPUState, eip) },
    SEG("cs", R_CS)
    SEG("ds", R_DS)
    SEG("es", R_ES)
B
bellard 已提交
2020
    SEG("ss", R_SS)
B
bellard 已提交
2021 2022 2023
    SEG("fs", R_FS)
    SEG("gs", R_GS)
    { "pc", 0, monitor_get_pc, },
2024
#elif defined(TARGET_PPC)
J
j_mayer 已提交
2025
    /* General purpose registers */
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
    { "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 已提交
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092
    /* 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 已提交
2093
    { "nip|pc", offsetof(CPUState, nip) },
2094 2095
    { "lr", offsetof(CPUState, lr) },
    { "ctr", offsetof(CPUState, ctr) },
2096
    { "decr", 0, &monitor_get_decr, },
2097
    { "ccr", 0, &monitor_get_ccr, },
J
j_mayer 已提交
2098
    /* Machine state register */
2099 2100
    { "msr", 0, &monitor_get_msr, },
    { "xer", 0, &monitor_get_xer, },
2101 2102
    { "tbu", 0, &monitor_get_tbu, },
    { "tbl", 0, &monitor_get_tbl, },
J
j_mayer 已提交
2103 2104 2105 2106 2107
#if defined(TARGET_PPC64)
    /* Address space register */
    { "asr", offsetof(CPUState, asr) },
#endif
    /* Segment registers */
2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125
    { "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 ... */
2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161
#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 已提交
2162
#ifndef TARGET_SPARC64
2163 2164
    { "psr", 0, &monitor_get_psr, },
    { "wim", offsetof(CPUState, wim) },
B
bellard 已提交
2165
#endif
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 2192 2193 2194 2195 2196 2197 2198 2199
    { "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 已提交
2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
#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
2226 2227 2228 2229
#endif
    { NULL },
};

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

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

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

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

A
aliguori 已提交
2278
static int64_t expr_sum(Monitor *mon);
2279

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

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

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


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

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

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

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

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

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

A
aliguori 已提交
2444
static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2445 2446 2447 2448 2449 2450
{
    pch = *pp;
    if (setjmp(expr_env)) {
        *pp = pch;
        return -1;
    }
2451
    while (qemu_isspace(*pch))
2452
        pch++;
A
aliguori 已提交
2453
    *pval = expr_sum(mon);
2454 2455 2456 2457 2458 2459 2460 2461 2462 2463
    *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 已提交
2464
    q = buf;
2465
    p = *pp;
2466
    while (qemu_isspace(*p))
2467 2468 2469
        p++;
    if (*p == '\0') {
    fail:
B
bellard 已提交
2470
        *q = '\0';
2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505
        *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 已提交
2506
            qemu_printf("unterminated string\n");
2507 2508 2509 2510
            goto fail;
        }
        p++;
    } else {
2511
        while (*p != '\0' && !qemu_isspace(*p)) {
2512 2513 2514 2515 2516 2517
            if ((q - buf) < buf_size - 1) {
                *q++ = *p;
            }
            p++;
        }
    }
B
bellard 已提交
2518
    *q = '\0';
2519 2520 2521 2522
    *pp = p;
    return 0;
}

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

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

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

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

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

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

    *key = str;
    return ++p;
}

2576 2577 2578 2579 2580
static int default_fmt_format = 'x';
static int default_fmt_size = 4;

#define MAX_ARGS 16

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

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

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

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

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

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

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

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

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

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

2812
    return cmd;
G
Gerd Hoffmann 已提交
2813

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

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

    qdict = qdict_new();

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

        qemu_errors_to_mon(mon);

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

        qemu_errors_to_previous();
    }

2838
    QDECREF(qdict);
B
bellard 已提交
2839 2840
}

B
bellard 已提交
2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858
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))) {
2859
            readline_add_completion(cur_mon->rs, cmd);
B
bellard 已提交
2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875
        }
        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;

2876
    p = strrchr(input, '/');
B
bellard 已提交
2877 2878 2879
    if (!p) {
        input_path_len = 0;
        pstrcpy(file_prefix, sizeof(file_prefix), input);
B
blueswir1 已提交
2880
        pstrcpy(path, sizeof(path), ".");
B
bellard 已提交
2881 2882 2883 2884 2885 2886 2887 2888 2889
    } 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 已提交
2890 2891
    monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
                   input, path, file_prefix);
B
bellard 已提交
2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902
#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 已提交
2903 2904 2905
            if (input_path_len < sizeof(file))
                pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
                        d->d_name);
B
bellard 已提交
2906 2907 2908 2909 2910
            /* 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 已提交
2911
                pstrcat(file, sizeof(file), "/");
2912
            readline_add_completion(cur_mon->rs, file);
B
bellard 已提交
2913 2914 2915 2916 2917
        }
    }
    closedir(ffs);
}

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

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

/* 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(;;) {
2940
        while (qemu_isspace(*p))
B
bellard 已提交
2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954
            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;
}

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

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

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

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

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

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

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

3068 3069
    cur_mon = opaque;

3070 3071 3072 3073 3074 3075 3076 3077 3078
    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 已提交
3079

3080 3081
    cur_mon = old_mon;
}
3082

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

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

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

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

3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122
    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;
3123

3124 3125 3126 3127 3128 3129 3130
    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;
    }
3131 3132
}

3133 3134 3135 3136 3137 3138 3139 3140 3141

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

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

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

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

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

3163 3164
    qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event,
                          mon);
3165 3166

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

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

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

3183
    monitor_read_command(mon, 1);
B
bellard 已提交
3184
}
3185

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

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

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

3201 3202
    mon->password_completion_cb = completion_cb;
    mon->password_opaque = opaque;
3203

3204 3205 3206 3207
    err = monitor_read_password(mon, bdrv_password_cb, bs);

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

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

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

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

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

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

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

void qemu_errors_to_previous(void)
{
    QemuErrorSink *sink;

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

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

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