monitor.c 120.9 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"
32
#include "hw/loader.h"
P
pbrook 已提交
33 34
#include "gdbstub.h"
#include "net.h"
35
#include "net/slirp.h"
P
pbrook 已提交
36 37
#include "qemu-char.h"
#include "sysemu.h"
A
aliguori 已提交
38 39
#include "monitor.h"
#include "readline.h"
P
pbrook 已提交
40 41 42
#include "console.h"
#include "block.h"
#include "audio/audio.h"
43
#include "disas.h"
A
aliguori 已提交
44
#include "balloon.h"
45
#include "qemu-timer.h"
A
aliguori 已提交
46
#include "migration.h"
A
aliguori 已提交
47
#include "kvm.h"
48
#include "acl.h"
49
#include "qint.h"
50
#include "qfloat.h"
51
#include "qlist.h"
52
#include "qdict.h"
L
Luiz Capitulino 已提交
53
#include "qbool.h"
54
#include "qstring.h"
L
Luiz Capitulino 已提交
55
#include "qerror.h"
L
Luiz Capitulino 已提交
56
#include "qjson.h"
L
Luiz Capitulino 已提交
57 58
#include "json-streamer.h"
#include "json-parser.h"
59
#include "osdep.h"
T
ths 已提交
60

B
bellard 已提交
61
//#define DEBUG
B
bellard 已提交
62
//#define DEBUG_COMPLETION
B
bellard 已提交
63

64 65
/*
 * Supported types:
66
 *
67
 * 'F'          filename
B
bellard 已提交
68
 * 'B'          block device name
69
 * 's'          string (accept optional quote)
B
bellard 已提交
70 71
 * 'i'          32 bit integer
 * 'l'          target long (32 or 64 bit)
72 73
 * 'M'          just like 'l', except in user mode the value is
 *              multiplied by 2^20 (think Mebibyte)
74 75 76 77
 * 'b'          double
 *              user mode accepts an optional G, g, M, m, K, k suffix,
 *              which multiplies the value by 2^30 for suffixes G and
 *              g, 2^20 for M and m, 2^10 for K and k
78 79 80
 * 'T'          double
 *              user mode accepts an optional ms, us, ns suffix,
 *              which divides the value by 1e3, 1e6, 1e9, respectively
81 82
 * '/'          optional gdb-like print format (like "/10x")
 *
83 84 85
 * '?'          optional type (for all types, except '/')
 * '.'          other form of optional type (for 'i' and 'l')
 * '-'          optional parameter (eg. '-f')
86 87 88
 *
 */

89 90 91 92 93 94
typedef struct MonitorCompletionData MonitorCompletionData;
struct MonitorCompletionData {
    Monitor *mon;
    void (*user_print)(Monitor *mon, const QObject *data);
};

A
Anthony Liguori 已提交
95
typedef struct mon_cmd_t {
B
bellard 已提交
96
    const char *name;
97
    const char *args_type;
B
bellard 已提交
98 99
    const char *params;
    const char *help;
100
    void (*user_print)(Monitor *mon, const QObject *data);
L
Luiz Capitulino 已提交
101 102
    union {
        void (*info)(Monitor *mon);
103
        void (*info_new)(Monitor *mon, QObject **ret_data);
104
        int  (*info_async)(Monitor *mon, MonitorCompletion *cb, void *opaque);
105
        void (*cmd)(Monitor *mon, const QDict *qdict);
106
        void (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
107 108
        int  (*cmd_async)(Monitor *mon, const QDict *params,
                          MonitorCompletion *cb, void *opaque);
L
Luiz Capitulino 已提交
109
    } mhandler;
110
    int async;
A
Anthony Liguori 已提交
111
} mon_cmd_t;
B
bellard 已提交
112

113
/* file descriptors passed via SCM_RIGHTS */
A
Anthony Liguori 已提交
114 115
typedef struct mon_fd_t mon_fd_t;
struct mon_fd_t {
116 117
    char *name;
    int fd;
A
Anthony Liguori 已提交
118
    QLIST_ENTRY(mon_fd_t) next;
119 120
};

L
Luiz Capitulino 已提交
121 122
typedef struct MonitorControl {
    QObject *id;
123
    int print_enabled;
L
Luiz Capitulino 已提交
124 125 126
    JSONMessageParser parser;
} MonitorControl;

127 128
struct Monitor {
    CharDriverState *chr;
G
Gerd Hoffmann 已提交
129 130
    int mux_out;
    int reset_seen;
131 132 133 134 135
    int flags;
    int suspend_cnt;
    uint8_t outbuf[1024];
    int outbuf_index;
    ReadLineState *rs;
L
Luiz Capitulino 已提交
136
    MonitorControl *mc;
137 138 139
    CPUState *mon_cpu;
    BlockDriverCompletionFunc *password_completion_cb;
    void *password_opaque;
L
Luiz Capitulino 已提交
140
    QError *error;
A
Anthony Liguori 已提交
141
    QLIST_HEAD(,mon_fd_t) fds;
B
Blue Swirl 已提交
142
    QLIST_ENTRY(Monitor) entry;
143 144
};

B
Blue Swirl 已提交
145
static QLIST_HEAD(mon_list, Monitor) mon_list;
146

A
Anthony Liguori 已提交
147 148
static const mon_cmd_t mon_cmds[];
static const mon_cmd_t info_cmds[];
B
bellard 已提交
149

150
Monitor *cur_mon = NULL;
A
aliguori 已提交
151

152 153
static void monitor_command_cb(Monitor *mon, const char *cmdline,
                               void *opaque);
154

155 156 157 158 159 160
/* Return true if in control mode, false otherwise */
static inline int monitor_ctrl_mode(const Monitor *mon)
{
    return (mon->flags & MONITOR_USE_CONTROL);
}

161 162
static void monitor_read_command(Monitor *mon, int show_prompt)
{
163 164 165
    if (!mon->rs)
        return;

166 167 168 169
    readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
    if (show_prompt)
        readline_show_prompt(mon->rs);
}
B
bellard 已提交
170

171 172
static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
                                 void *opaque)
173
{
174 175 176 177
    if (monitor_ctrl_mode(mon)) {
        qemu_error_new(QERR_MISSING_PARAMETER, "password");
        return -EINVAL;
    } else if (mon->rs) {
178 179 180 181 182 183 184
        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;
    }
185 186
}

A
aliguori 已提交
187
void monitor_flush(Monitor *mon)
188
{
G
Gerd Hoffmann 已提交
189
    if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
190 191
        qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
        mon->outbuf_index = 0;
192 193 194 195
    }
}

/* flush at every end of line or if the buffer is full */
A
aliguori 已提交
196
static void monitor_puts(Monitor *mon, const char *str)
197
{
T
ths 已提交
198
    char c;
199

200 201 202 203
    for(;;) {
        c = *str++;
        if (c == '\0')
            break;
B
bellard 已提交
204
        if (c == '\n')
205 206 207 208
            mon->outbuf[mon->outbuf_index++] = '\r';
        mon->outbuf[mon->outbuf_index++] = c;
        if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
            || c == '\n')
A
aliguori 已提交
209
            monitor_flush(mon);
210 211 212
    }
}

A
aliguori 已提交
213
void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
B
bellard 已提交
214
{
215 216 217
    if (!mon)
        return;

218 219 220 221 222 223 224
    if (mon->mc && !mon->mc->print_enabled) {
        qemu_error_new(QERR_UNDEFINED_ERROR);
    } else {
        char buf[4096];
        vsnprintf(buf, sizeof(buf), fmt, ap);
        monitor_puts(mon, buf);
    }
B
bellard 已提交
225 226
}

A
aliguori 已提交
227
void monitor_printf(Monitor *mon, const char *fmt, ...)
B
bellard 已提交
228
{
229 230
    va_list ap;
    va_start(ap, fmt);
A
aliguori 已提交
231
    monitor_vprintf(mon, fmt, ap);
232
    va_end(ap);
B
bellard 已提交
233 234
}

A
aliguori 已提交
235
void monitor_print_filename(Monitor *mon, const char *filename)
236 237 238 239
{
    int i;

    for (i = 0; filename[i]; i++) {
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
        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;
        }
259 260 261
    }
}

B
bellard 已提交
262 263 264 265
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
A
aliguori 已提交
266
    monitor_vprintf((Monitor *)stream, fmt, ap);
B
bellard 已提交
267 268 269 270
    va_end(ap);
    return 0;
}

271 272
static void monitor_user_noop(Monitor *mon, const QObject *data) { }

273 274 275 276 277
static inline int monitor_handler_ported(const mon_cmd_t *cmd)
{
    return cmd->user_print != NULL;
}

278 279 280 281 282
static inline bool monitor_handler_is_async(const mon_cmd_t *cmd)
{
    return cmd->async != 0;
}

L
Luiz Capitulino 已提交
283 284 285 286 287
static inline int monitor_has_error(const Monitor *mon)
{
    return mon->error != NULL;
}

L
Luiz Capitulino 已提交
288 289 290 291 292 293 294
static void monitor_json_emitter(Monitor *mon, const QObject *data)
{
    QString *json;

    json = qobject_to_json(data);
    assert(json != NULL);

295
    mon->mc->print_enabled = 1;
L
Luiz Capitulino 已提交
296
    monitor_printf(mon, "%s\n", qstring_get_str(json));
297 298
    mon->mc->print_enabled = 0;

L
Luiz Capitulino 已提交
299 300 301
    QDECREF(json);
}

L
Luiz Capitulino 已提交
302 303 304 305 306 307 308 309 310 311 312 313
static void monitor_protocol_emitter(Monitor *mon, QObject *data)
{
    QDict *qmp;

    qmp = qdict_new();

    if (!monitor_has_error(mon)) {
        /* success response */
        if (data) {
            qobject_incref(data);
            qdict_put_obj(qmp, "return", data);
        } else {
314 315
            /* return an empty QDict by default */
            qdict_put(qmp, "return", qdict_new());
L
Luiz Capitulino 已提交
316 317 318
        }
    } else {
        /* error response */
319
        qdict_put(mon->error->error, "desc", qerror_human(mon->error));
L
Luiz Capitulino 已提交
320 321 322 323 324 325
        qdict_put(qmp, "error", mon->error->error);
        QINCREF(mon->error->error);
        QDECREF(mon->error);
        mon->error = NULL;
    }

L
Luiz Capitulino 已提交
326 327 328 329 330
    if (mon->mc->id) {
        qdict_put_obj(qmp, "id", mon->mc->id);
        mon->mc->id = NULL;
    }

L
Luiz Capitulino 已提交
331 332 333 334
    monitor_json_emitter(mon, QOBJECT(qmp));
    QDECREF(qmp);
}

335 336 337 338
static void timestamp_put(QDict *qdict)
{
    int err;
    QObject *obj;
339
    qemu_timeval tv;
340

341
    err = qemu_gettimeofday(&tv);
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
    if (err < 0)
        return;

    obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
                                "'microseconds': %" PRId64 " }",
                                (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
    assert(obj != NULL);

    qdict_put_obj(qdict, "timestamp", obj);
}

/**
 * monitor_protocol_event(): Generate a Monitor event
 *
 * Event-specific data can be emitted through the (optional) 'data' parameter.
 */
void monitor_protocol_event(MonitorEvent event, QObject *data)
{
    QDict *qmp;
    const char *event_name;
362
    Monitor *mon;
363

364
    assert(event < QEVENT_MAX);
365 366

    switch (event) {
367
        case QEVENT_DEBUG:
368 369
            event_name = "DEBUG";
            break;
370
        case QEVENT_SHUTDOWN:
371 372
            event_name = "SHUTDOWN";
            break;
373
        case QEVENT_RESET:
374 375
            event_name = "RESET";
            break;
376
        case QEVENT_POWERDOWN:
377 378
            event_name = "POWERDOWN";
            break;
379
        case QEVENT_STOP:
380 381
            event_name = "STOP";
            break;
382 383 384
        case QEVENT_VNC_CONNECTED:
            event_name = "VNC_CONNECTED";
            break;
385 386 387
        case QEVENT_VNC_INITIALIZED:
            event_name = "VNC_INITIALIZED";
            break;
388 389 390
        case QEVENT_VNC_DISCONNECTED:
            event_name = "VNC_DISCONNECTED";
            break;
391 392 393
        case QEVENT_BLOCK_IO_ERROR:
            event_name = "BLOCK_IO_ERROR";
            break;
394 395 396 397 398 399 400 401
        default:
            abort();
            break;
    }

    qmp = qdict_new();
    timestamp_put(qmp);
    qdict_put(qmp, "event", qstring_from_str(event_name));
402 403
    if (data) {
        qobject_incref(data);
404
        qdict_put_obj(qmp, "data", data);
405
    }
406

407
    QLIST_FOREACH(mon, &mon_list, entry) {
408 409 410
        if (monitor_ctrl_mode(mon)) {
            monitor_json_emitter(mon, QOBJECT(qmp));
        }
411
    }
412 413 414
    QDECREF(qmp);
}

B
bellard 已提交
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
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
Anthony Liguori 已提交
435
static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
A
aliguori 已提交
436
                          const char *prefix, const char *name)
B
bellard 已提交
437
{
A
Anthony Liguori 已提交
438
    const mon_cmd_t *cmd;
B
bellard 已提交
439 440 441

    for(cmd = cmds; cmd->name != NULL; cmd++) {
        if (!name || !strcmp(name, cmd->name))
A
aliguori 已提交
442 443
            monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
                           cmd->params, cmd->help);
B
bellard 已提交
444 445 446
    }
}

A
aliguori 已提交
447
static void help_cmd(Monitor *mon, const char *name)
B
bellard 已提交
448 449
{
    if (name && !strcmp(name, "info")) {
A
aliguori 已提交
450
        help_cmd_dump(mon, info_cmds, "info ", NULL);
B
bellard 已提交
451
    } else {
A
aliguori 已提交
452
        help_cmd_dump(mon, mon_cmds, "", name);
453
        if (name && !strcmp(name, "log")) {
B
blueswir1 已提交
454
            const CPULogItem *item;
A
aliguori 已提交
455 456
            monitor_printf(mon, "Log items (comma separated):\n");
            monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
457
            for(item = cpu_log_items; item->mask != 0; item++) {
A
aliguori 已提交
458
                monitor_printf(mon, "%-10s %s\n", item->name, item->help);
459 460
            }
        }
B
bellard 已提交
461 462 463
    }
}

464
static void do_help_cmd(Monitor *mon, const QDict *qdict)
465
{
466
    help_cmd(mon, qdict_get_try_str(qdict, "name"));
467 468
}

469
static void do_commit(Monitor *mon, const QDict *qdict)
B
bellard 已提交
470
{
G
Gerd Hoffmann 已提交
471 472
    int all_devices;
    DriveInfo *dinfo;
473
    const char *device = qdict_get_str(qdict, "device");
474

B
bellard 已提交
475
    all_devices = !strcmp(device, "all");
B
Blue Swirl 已提交
476
    QTAILQ_FOREACH(dinfo, &drives, next) {
G
Gerd Hoffmann 已提交
477
        if (!all_devices)
L
Luiz Capitulino 已提交
478
            if (strcmp(bdrv_get_device_name(dinfo->bdrv), device))
G
Gerd Hoffmann 已提交
479 480
                continue;
        bdrv_commit(dinfo->bdrv);
B
bellard 已提交
481 482 483
    }
}

484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
static void user_monitor_complete(void *opaque, QObject *ret_data)
{
    MonitorCompletionData *data = (MonitorCompletionData *)opaque; 

    if (ret_data) {
        data->user_print(data->mon, ret_data);
    }
    monitor_resume(data->mon);
    qemu_free(data);
}

static void qmp_monitor_complete(void *opaque, QObject *ret_data)
{
    monitor_protocol_emitter(opaque, ret_data);
}

static void qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
                                  const QDict *params)
{
    cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
}

static void qmp_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
{
    cmd->mhandler.info_async(mon, qmp_monitor_complete, mon);
}

static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
                                   const QDict *params)
{
    int ret;

    MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
    cb_data->mon = mon;
    cb_data->user_print = cmd->user_print;
    monitor_suspend(mon);
    ret = cmd->mhandler.cmd_async(mon, params,
                                  user_monitor_complete, cb_data);
    if (ret < 0) {
        monitor_resume(mon);
        qemu_free(cb_data);
    }
}

static void user_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
{
    int ret;

    MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
    cb_data->mon = mon;
    cb_data->user_print = cmd->user_print;
    monitor_suspend(mon);
    ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);
    if (ret < 0) {
        monitor_resume(mon);
        qemu_free(cb_data);
    }
}

543
static void do_info(Monitor *mon, const QDict *qdict, QObject **ret_data)
B
bellard 已提交
544
{
A
Anthony Liguori 已提交
545
    const mon_cmd_t *cmd;
546
    const char *item = qdict_get_try_str(qdict, "item");
B
bellard 已提交
547

L
Luiz Capitulino 已提交
548 549
    if (!item) {
        assert(monitor_ctrl_mode(mon) == 0);
B
bellard 已提交
550
        goto help;
L
Luiz Capitulino 已提交
551
    }
552 553

    for (cmd = info_cmds; cmd->name != NULL; cmd++) {
554
        if (compare_cmd(item, cmd->name))
555
            break;
B
bellard 已提交
556
    }
557

L
Luiz Capitulino 已提交
558 559 560 561 562
    if (cmd->name == NULL) {
        if (monitor_ctrl_mode(mon)) {
            qemu_error_new(QERR_COMMAND_NOT_FOUND, item);
            return;
        }
563
        goto help;
L
Luiz Capitulino 已提交
564
    }
565

566 567 568 569 570 571 572 573 574 575 576 577 578
    if (monitor_handler_is_async(cmd)) {
        if (monitor_ctrl_mode(mon)) {
            qmp_async_info_handler(mon, cmd);
        } else {
            user_async_info_handler(mon, cmd);
        }
        /*
         * Indicate that this command is asynchronous and will not return any
         * data (not even empty).  Instead, the data will be returned via a
         * completion callback.
         */
        *ret_data = qobject_from_jsonf("{ '__mon_async': 'return' }");
    } else if (monitor_handler_ported(cmd)) {
579
        cmd->mhandler.info_new(mon, ret_data);
L
Luiz Capitulino 已提交
580 581 582 583 584 585 586 587 588

        if (!monitor_ctrl_mode(mon)) {
            /*
             * User Protocol function is called here, Monitor Protocol is
             * handled by monitor_call_handler()
             */
            if (*ret_data)
                cmd->user_print(mon, *ret_data);
        }
589
    } else {
L
Luiz Capitulino 已提交
590 591 592 593 594 595
        if (monitor_ctrl_mode(mon)) {
            /* handler not converted yet */
            qemu_error_new(QERR_COMMAND_NOT_FOUND, item);
        } else {
            cmd->mhandler.info(mon);
        }
596 597
    }

B
bellard 已提交
598
    return;
599 600 601

help:
    help_cmd(mon, "info");
B
bellard 已提交
602 603
}

604 605 606 607 608 609 610 611 612 613
static void do_info_version_print(Monitor *mon, const QObject *data)
{
    QDict *qdict;

    qdict = qobject_to_qdict(data);

    monitor_printf(mon, "%s%s\n", qdict_get_str(qdict, "qemu"),
                                  qdict_get_str(qdict, "package"));
}

614 615
/**
 * do_info_version(): Show QEMU version
616 617 618 619 620 621 622 623 624
 *
 * Return a QDict with the following information:
 *
 * - "qemu": QEMU's version
 * - "package": package's version
 *
 * Example:
 *
 * { "qemu": "0.11.50", "package": "" }
625 626
 */
static void do_info_version(Monitor *mon, QObject **ret_data)
B
bellard 已提交
627
{
628 629
    *ret_data = qobject_from_jsonf("{ 'qemu': %s, 'package': %s }",
                                   QEMU_VERSION, QEMU_PKGVERSION);
B
bellard 已提交
630 631
}

632
static void do_info_name_print(Monitor *mon, const QObject *data)
T
ths 已提交
633
{
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
    QDict *qdict;

    qdict = qobject_to_qdict(data);
    if (qdict_size(qdict) == 0) {
        return;
    }

    monitor_printf(mon, "%s\n", qdict_get_str(qdict, "name"));
}

/**
 * do_info_name(): Show VM name
 *
 * Return a QDict with the following information:
 *
 * - "name": VM's name (optional)
 *
 * Example:
 *
 * { "name": "qemu-name" }
 */
static void do_info_name(Monitor *mon, QObject **ret_data)
{
    *ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :
                            qobject_from_jsonf("{}");
T
ths 已提交
659 660
}

661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
static QObject *get_cmd_dict(const char *name)
{
    const char *p;

    /* Remove '|' from some commands */
    p = strchr(name, '|');
    if (p) {
        p++;
    } else {
        p = name;
    }

    return qobject_from_jsonf("{ 'name': %s }", p);
}

676 677 678
/**
 * do_info_commands(): List QMP available commands
 *
679 680 681 682 683 684 685 686 687 688
 * Each command is represented by a QDict, the returned QObject is a QList
 * of all commands.
 *
 * The QDict contains:
 *
 * - "name": command's name
 *
 * Example:
 *
 * { [ { "name": "query-balloon" }, { "name": "system_powerdown" } ] }
689 690 691 692 693 694 695 696 697 698
 */
static void do_info_commands(Monitor *mon, QObject **ret_data)
{
    QList *cmd_list;
    const mon_cmd_t *cmd;

    cmd_list = qlist_new();

    for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
        if (monitor_handler_ported(cmd) && !compare_cmd(cmd->name, "info")) {
699
            qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));
700 701 702 703 704 705 706
        }
    }

    for (cmd = info_cmds; cmd->name != NULL; cmd++) {
        if (monitor_handler_ported(cmd)) {
            char buf[128];
            snprintf(buf, sizeof(buf), "query-%s", cmd->name);
707
            qlist_append_obj(cmd_list, get_cmd_dict(buf));
708 709 710 711 712 713
        }
    }

    *ret_data = QOBJECT(cmd_list);
}

A
aurel32 已提交
714
#if defined(TARGET_I386)
715
static void do_info_hpet_print(Monitor *mon, const QObject *data)
A
aliguori 已提交
716
{
A
aliguori 已提交
717
    monitor_printf(mon, "HPET is %s by QEMU\n",
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
                   qdict_get_bool(qobject_to_qdict(data), "enabled") ?
                   "enabled" : "disabled");
}

/**
 * do_info_hpet(): Show HPET state
 *
 * Return a QDict with the following information:
 *
 * - "enabled": true if hpet if enabled, false otherwise
 *
 * Example:
 *
 * { "enabled": true }
 */
static void do_info_hpet(Monitor *mon, QObject **ret_data)
{
    *ret_data = qobject_from_jsonf("{ 'enabled': %i }", !no_hpet);
A
aliguori 已提交
736
}
A
aurel32 已提交
737
#endif
A
aliguori 已提交
738

739
static void do_info_uuid_print(Monitor *mon, const QObject *data)
740
{
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
    monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));
}

/**
 * do_info_uuid(): Show VM UUID
 *
 * Return a QDict with the following information:
 *
 * - "UUID": Universally Unique Identifier
 *
 * Example:
 *
 * { "UUID": "550e8400-e29b-41d4-a716-446655440000" }
 */
static void do_info_uuid(Monitor *mon, QObject **ret_data)
{
    char uuid[64];

    snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
A
aliguori 已提交
760 761 762 763
                   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]);
764
    *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);
765 766
}

B
bellard 已提交
767
/* get the current CPU defined by the user */
768
static int mon_set_cpu(int cpu_index)
B
bellard 已提交
769 770 771 772 773
{
    CPUState *env;

    for(env = first_cpu; env != NULL; env = env->next_cpu) {
        if (env->cpu_index == cpu_index) {
774
            cur_mon->mon_cpu = env;
B
bellard 已提交
775 776 777 778 779 780
            return 0;
        }
    }
    return -1;
}

781
static CPUState *mon_get_cpu(void)
B
bellard 已提交
782
{
783
    if (!cur_mon->mon_cpu) {
B
bellard 已提交
784 785
        mon_set_cpu(0);
    }
786
    cpu_synchronize_state(cur_mon->mon_cpu);
787
    return cur_mon->mon_cpu;
B
bellard 已提交
788 789
}

A
aliguori 已提交
790
static void do_info_registers(Monitor *mon)
791
{
B
bellard 已提交
792 793
    CPUState *env;
    env = mon_get_cpu();
794
#ifdef TARGET_I386
A
aliguori 已提交
795
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
B
bellard 已提交
796
                   X86_DUMP_FPU);
797
#else
A
aliguori 已提交
798
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
B
bellard 已提交
799
                   0);
800 801 802
#endif
}

803 804 805 806 807 808 809 810 811
static void print_cpu_iter(QObject *obj, void *opaque)
{
    QDict *cpu;
    int active = ' ';
    Monitor *mon = opaque;

    assert(qobject_type(obj) == QTYPE_QDICT);
    cpu = qobject_to_qdict(obj);

812
    if (qdict_get_bool(cpu, "current")) {
813
        active = '*';
814
    }
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833

    monitor_printf(mon, "%c CPU #%d: ", active, (int)qdict_get_int(cpu, "CPU"));

#if defined(TARGET_I386)
    monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
                   (target_ulong) qdict_get_int(cpu, "pc"));
#elif defined(TARGET_PPC)
    monitor_printf(mon, "nip=0x" TARGET_FMT_lx,
                   (target_long) qdict_get_int(cpu, "nip"));
#elif defined(TARGET_SPARC)
    monitor_printf(mon, "pc=0x " TARGET_FMT_lx,
                   (target_long) qdict_get_int(cpu, "pc"));
    monitor_printf(mon, "npc=0x" TARGET_FMT_lx,
                   (target_long) qdict_get_int(cpu, "npc"));
#elif defined(TARGET_MIPS)
    monitor_printf(mon, "PC=0x" TARGET_FMT_lx,
                   (target_long) qdict_get_int(cpu, "PC"));
#endif

834
    if (qdict_get_bool(cpu, "halted")) {
835
        monitor_printf(mon, " (halted)");
836
    }
837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852

    monitor_printf(mon, "\n");
}

static void monitor_print_cpus(Monitor *mon, const QObject *data)
{
    QList *cpu_list;

    assert(qobject_type(data) == QTYPE_QLIST);
    cpu_list = qobject_to_qlist(data);
    qlist_iter(cpu_list, print_cpu_iter, mon);
}

/**
 * do_info_cpus(): Show CPU information
 *
853
 * Return a QList. Each CPU is represented by a QDict, which contains:
854
 *
855 856 857 858 859 860 861 862
 * - "cpu": CPU index
 * - "current": true if this is the current CPU, false otherwise
 * - "halted": true if the cpu is halted, false otherwise
 * - Current program counter. The key's name depends on the architecture:
 *      "pc": i386/x86)64
 *      "nip": PPC
 *      "pc" and "npc": sparc
 *      "PC": mips
863
 *
864 865 866 867
 * Example:
 *
 * [ { "CPU": 0, "current": true, "halted": false, "pc": 3227107138 },
 *   { "CPU": 1, "current": false, "halted": true, "pc": 7108165 } ]
868 869
 */
static void do_info_cpus(Monitor *mon, QObject **ret_data)
B
bellard 已提交
870 871
{
    CPUState *env;
872 873 874
    QList *cpu_list;

    cpu_list = qlist_new();
B
bellard 已提交
875 876 877 878 879

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

    for(env = first_cpu; env != NULL; env = env->next_cpu) {
880 881
        QDict *cpu;
        QObject *obj;
882

883
        cpu_synchronize_state(env);
884

885 886 887 888 889 890
        obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",
                                 env->cpu_index, env == mon->mon_cpu,
                                 env->halted);
        assert(obj != NULL);

        cpu = qobject_to_qdict(obj);
891

B
bellard 已提交
892
#if defined(TARGET_I386)
893
        qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));
B
bellard 已提交
894
#elif defined(TARGET_PPC)
895
        qdict_put(cpu, "nip", qint_from_int(env->nip));
B
bellard 已提交
896
#elif defined(TARGET_SPARC)
897 898
        qdict_put(cpu, "pc", qint_from_int(env->pc));
        qdict_put(cpu, "npc", qint_from_int(env->npc));
899
#elif defined(TARGET_MIPS)
900
        qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));
B
bellard 已提交
901
#endif
902 903

        qlist_append(cpu_list, cpu);
B
bellard 已提交
904
    }
905 906

    *ret_data = QOBJECT(cpu_list);
B
bellard 已提交
907 908
}

909
static void do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)
B
bellard 已提交
910
{
911
    int index = qdict_get_int(qdict, "index");
B
bellard 已提交
912
    if (mon_set_cpu(index) < 0)
913
        qemu_error_new(QERR_INVALID_PARAMETER, "index");
B
bellard 已提交
914 915
}

A
aliguori 已提交
916
static void do_info_jit(Monitor *mon)
B
bellard 已提交
917
{
A
aliguori 已提交
918
    dump_exec_info((FILE *)mon, monitor_fprintf);
B
bellard 已提交
919 920
}

A
aliguori 已提交
921
static void do_info_history(Monitor *mon)
B
bellard 已提交
922 923
{
    int i;
924
    const char *str;
925

926 927
    if (!mon->rs)
        return;
928 929
    i = 0;
    for(;;) {
930
        str = readline_get_history(mon->rs, i);
931 932
        if (!str)
            break;
A
aliguori 已提交
933
        monitor_printf(mon, "%d: '%s'\n", i, str);
B
bellard 已提交
934
        i++;
B
bellard 已提交
935 936 937
    }
}

938 939
#if defined(TARGET_PPC)
/* XXX: not implemented in other targets */
A
aliguori 已提交
940
static void do_info_cpu_stats(Monitor *mon)
941 942 943 944
{
    CPUState *env;

    env = mon_get_cpu();
A
aliguori 已提交
945
    cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
946 947 948
}
#endif

949 950 951 952
/**
 * do_quit(): Quit QEMU execution
 */
static void do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
B
bellard 已提交
953 954 955 956
{
    exit(0);
}

A
aliguori 已提交
957
static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
B
bellard 已提交
958 959 960 961
{
    if (bdrv_is_inserted(bs)) {
        if (!force) {
            if (!bdrv_is_removable(bs)) {
962 963
                qemu_error_new(QERR_DEVICE_NOT_REMOVABLE,
                               bdrv_get_device_name(bs));
B
bellard 已提交
964 965 966
                return -1;
            }
            if (bdrv_is_locked(bs)) {
967
                qemu_error_new(QERR_DEVICE_LOCKED, bdrv_get_device_name(bs));
B
bellard 已提交
968 969 970 971 972 973 974 975
                return -1;
            }
        }
        bdrv_close(bs);
    }
    return 0;
}

976
static void do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data)
B
bellard 已提交
977 978
{
    BlockDriverState *bs;
979
    int force = qdict_get_int(qdict, "force");
L
Luiz Capitulino 已提交
980
    const char *filename = qdict_get_str(qdict, "device");
B
bellard 已提交
981

982
    bs = bdrv_find(filename);
B
bellard 已提交
983
    if (!bs) {
984
        qemu_error_new(QERR_DEVICE_NOT_FOUND, filename);
B
bellard 已提交
985 986
        return;
    }
A
aliguori 已提交
987
    eject_device(mon, bs, force);
B
bellard 已提交
988 989
}

990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
static void do_block_set_passwd(Monitor *mon, const QDict *qdict,
                                QObject **ret_data)
{
    BlockDriverState *bs;

    bs = bdrv_find(qdict_get_str(qdict, "device"));
    if (!bs) {
        qemu_error_new(QERR_DEVICE_NOT_FOUND, qdict_get_str(qdict, "device"));
        return;
    }

    if (bdrv_set_key(bs, qdict_get_str(qdict, "password")) < 0) {
        qemu_error_new(QERR_INVALID_PASSWORD);
    }
}

A
aliguori 已提交
1006 1007
static void do_change_block(Monitor *mon, const char *device,
                            const char *filename, const char *fmt)
B
bellard 已提交
1008 1009
{
    BlockDriverState *bs;
1010
    BlockDriver *drv = NULL;
B
bellard 已提交
1011

1012
    bs = bdrv_find(device);
B
bellard 已提交
1013
    if (!bs) {
1014
        qemu_error_new(QERR_DEVICE_NOT_FOUND, device);
B
bellard 已提交
1015 1016
        return;
    }
1017
    if (fmt) {
1018
        drv = bdrv_find_whitelisted_format(fmt);
1019
        if (!drv) {
1020
            qemu_error_new(QERR_INVALID_BLOCK_FORMAT, fmt);
1021 1022 1023
            return;
        }
    }
A
aliguori 已提交
1024
    if (eject_device(mon, bs, 0) < 0)
B
bellard 已提交
1025
        return;
1026
    bdrv_open2(bs, filename, BDRV_O_RDWR, drv);
A
aliguori 已提交
1027
    monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
1028 1029
}

1030
static void change_vnc_password(const char *password)
1031 1032
{
    if (vnc_display_password(NULL, password) < 0)
1033
        qemu_error_new(QERR_SET_PASSWD_FAILED);
1034

1035 1036 1037 1038 1039
}

static void change_vnc_password_cb(Monitor *mon, const char *password,
                                   void *opaque)
{
1040
    change_vnc_password(password);
1041
    monitor_read_command(mon, 1);
B
bellard 已提交
1042 1043
}

A
aliguori 已提交
1044
static void do_change_vnc(Monitor *mon, const char *target, const char *arg)
1045
{
1046
    if (strcmp(target, "passwd") == 0 ||
1047 1048
        strcmp(target, "password") == 0) {
        if (arg) {
1049
            char password[9];
1050 1051
            strncpy(password, arg, sizeof(password));
            password[sizeof(password) - 1] = '\0';
1052
            change_vnc_password(password);
1053
        } else {
A
aliguori 已提交
1054
            monitor_read_password(mon, change_vnc_password_cb, NULL);
1055
        }
1056
    } else {
1057
        if (vnc_display_open(NULL, target) < 0)
1058
            qemu_error_new(QERR_VNC_SERVER_FAILED, target);
1059
    }
1060 1061
}

1062 1063 1064 1065
/**
 * do_change(): Change a removable medium, or VNC configuration
 */
static void do_change(Monitor *mon, const QDict *qdict, QObject **ret_data)
1066
{
1067 1068 1069
    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");
1070
    if (strcmp(device, "vnc") == 0) {
1071
        do_change_vnc(mon, target, arg);
1072
    } else {
1073
        do_change_block(mon, device, target, arg);
1074 1075 1076
    }
}

1077
static void do_screen_dump(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1078
{
1079
    vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
B
bellard 已提交
1080 1081
}

1082
static void do_logfile(Monitor *mon, const QDict *qdict)
P
pbrook 已提交
1083
{
1084
    cpu_set_log_filename(qdict_get_str(qdict, "filename"));
P
pbrook 已提交
1085 1086
}

1087
static void do_log(Monitor *mon, const QDict *qdict)
1088 1089
{
    int mask;
1090
    const char *items = qdict_get_str(qdict, "items");
1091

1092
    if (!strcmp(items, "none")) {
1093 1094
        mask = 0;
    } else {
1095
        mask = cpu_str_to_log_mask(items);
1096
        if (!mask) {
A
aliguori 已提交
1097
            help_cmd(mon, "log");
1098 1099 1100 1101 1102 1103
            return;
        }
    }
    cpu_set_log(mask);
}

1104
static void do_singlestep(Monitor *mon, const QDict *qdict)
1105
{
1106
    const char *option = qdict_get_try_str(qdict, "option");
1107 1108 1109 1110 1111 1112 1113 1114 1115
    if (!option || !strcmp(option, "on")) {
        singlestep = 1;
    } else if (!strcmp(option, "off")) {
        singlestep = 0;
    } else {
        monitor_printf(mon, "unexpected option %s\n", option);
    }
}

1116 1117 1118 1119
/**
 * do_stop(): Stop VM execution
 */
static void do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
1120 1121 1122 1123
{
    vm_stop(EXCP_INTERRUPT);
}

1124
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
1125

A
aliguori 已提交
1126 1127 1128 1129 1130
struct bdrv_iterate_context {
    Monitor *mon;
    int err;
};

1131 1132 1133 1134
/**
 * do_cont(): Resume emulation.
 */
static void do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
1135
{
A
aliguori 已提交
1136
    struct bdrv_iterate_context context = { mon, 0 };
1137

A
aliguori 已提交
1138
    bdrv_iterate(encrypted_bdrv_it, &context);
1139
    /* only resume the vm if all keys are set and valid */
A
aliguori 已提交
1140
    if (!context.err)
1141
        vm_start();
1142 1143
}

1144 1145
static void bdrv_key_cb(void *opaque, int err)
{
A
aliguori 已提交
1146 1147
    Monitor *mon = opaque;

1148 1149
    /* another key was set successfully, retry to continue */
    if (!err)
1150
        do_cont(mon, NULL, NULL);
1151 1152 1153 1154
}

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

A
aliguori 已提交
1157 1158 1159 1160
    if (!context->err && bdrv_key_required(bs)) {
        context->err = -EBUSY;
        monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
                                    context->mon);
1161 1162 1163
    }
}

1164
static void do_gdbserver(Monitor *mon, const QDict *qdict)
1165
{
1166
    const char *device = qdict_get_try_str(qdict, "device");
1167 1168 1169 1170 1171 1172
    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) {
1173
        monitor_printf(mon, "Disabled gdbserver\n");
1174
    } else {
1175 1176
        monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
                       device);
1177 1178 1179
    }
}

1180
static void do_watchdog_action(Monitor *mon, const QDict *qdict)
R
Richard W.M. Jones 已提交
1181
{
1182
    const char *action = qdict_get_str(qdict, "action");
R
Richard W.M. Jones 已提交
1183 1184 1185 1186 1187
    if (select_watchdog_action(action) == -1) {
        monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
    }
}

A
aliguori 已提交
1188
static void monitor_printc(Monitor *mon, int c)
1189
{
A
aliguori 已提交
1190
    monitor_printf(mon, "'");
1191 1192
    switch(c) {
    case '\'':
A
aliguori 已提交
1193
        monitor_printf(mon, "\\'");
1194 1195
        break;
    case '\\':
A
aliguori 已提交
1196
        monitor_printf(mon, "\\\\");
1197 1198
        break;
    case '\n':
A
aliguori 已提交
1199
        monitor_printf(mon, "\\n");
1200 1201
        break;
    case '\r':
A
aliguori 已提交
1202
        monitor_printf(mon, "\\r");
1203 1204 1205
        break;
    default:
        if (c >= 32 && c <= 126) {
A
aliguori 已提交
1206
            monitor_printf(mon, "%c", c);
1207
        } else {
A
aliguori 已提交
1208
            monitor_printf(mon, "\\x%02x", c);
1209 1210 1211
        }
        break;
    }
A
aliguori 已提交
1212
    monitor_printf(mon, "'");
1213 1214
}

A
aliguori 已提交
1215
static void memory_dump(Monitor *mon, int count, int format, int wsize,
A
Anthony Liguori 已提交
1216
                        target_phys_addr_t addr, int is_physical)
1217
{
B
bellard 已提交
1218
    CPUState *env;
1219
    int l, line_size, i, max_digits, len;
1220 1221 1222 1223 1224 1225
    uint8_t buf[16];
    uint64_t v;

    if (format == 'i') {
        int flags;
        flags = 0;
B
bellard 已提交
1226
        env = mon_get_cpu();
1227
        if (!is_physical)
B
bellard 已提交
1228
            return;
1229
#ifdef TARGET_I386
1230
        if (wsize == 2) {
1231
            flags = 1;
1232 1233 1234
        } else if (wsize == 4) {
            flags = 0;
        } else {
B
bellard 已提交
1235
            /* as default we use the current CS size */
1236
            flags = 0;
B
bellard 已提交
1237 1238
            if (env) {
#ifdef TARGET_X86_64
1239
                if ((env->efer & MSR_EFER_LMA) &&
B
bellard 已提交
1240 1241 1242 1243 1244 1245 1246
                    (env->segs[R_CS].flags & DESC_L_MASK))
                    flags = 2;
                else
#endif
                if (!(env->segs[R_CS].flags & DESC_B_MASK))
                    flags = 1;
            }
1247 1248
        }
#endif
A
aliguori 已提交
1249
        monitor_disas(mon, env, addr, count, is_physical, flags);
1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
        return;
    }

    len = wsize * count;
    if (wsize == 1)
        line_size = 8;
    else
        line_size = 16;
    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) {
1278
        if (is_physical)
A
aliguori 已提交
1279
            monitor_printf(mon, TARGET_FMT_plx ":", addr);
1280
        else
A
aliguori 已提交
1281
            monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1282 1283 1284 1285 1286 1287
        l = len;
        if (l > line_size)
            l = line_size;
        if (is_physical) {
            cpu_physical_memory_rw(addr, buf, l, 0);
        } else {
B
bellard 已提交
1288
            env = mon_get_cpu();
1289
            if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
A
aliguori 已提交
1290
                monitor_printf(mon, " Cannot access memory\n");
1291 1292
                break;
            }
1293
        }
1294
        i = 0;
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
        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 已提交
1305
                v = (uint32_t)ldl_raw(buf + i);
1306 1307 1308 1309 1310
                break;
            case 8:
                v = ldq_raw(buf + i);
                break;
            }
A
aliguori 已提交
1311
            monitor_printf(mon, " ");
1312 1313
            switch(format) {
            case 'o':
A
aliguori 已提交
1314
                monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1315 1316
                break;
            case 'x':
A
aliguori 已提交
1317
                monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1318 1319
                break;
            case 'u':
A
aliguori 已提交
1320
                monitor_printf(mon, "%*" PRIu64, max_digits, v);
1321 1322
                break;
            case 'd':
A
aliguori 已提交
1323
                monitor_printf(mon, "%*" PRId64, max_digits, v);
1324 1325
                break;
            case 'c':
A
aliguori 已提交
1326
                monitor_printc(mon, v);
1327 1328 1329 1330
                break;
            }
            i += wsize;
        }
A
aliguori 已提交
1331
        monitor_printf(mon, "\n");
1332 1333 1334 1335 1336
        addr += l;
        len -= l;
    }
}

1337
static void do_memory_dump(Monitor *mon, const QDict *qdict)
1338
{
1339 1340 1341 1342 1343
    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 已提交
1344
    memory_dump(mon, count, format, size, addr, 0);
1345 1346
}

1347
static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
1348
{
1349 1350 1351
    int count = qdict_get_int(qdict, "count");
    int format = qdict_get_int(qdict, "format");
    int size = qdict_get_int(qdict, "size");
A
Anthony Liguori 已提交
1352
    target_phys_addr_t addr = qdict_get_int(qdict, "addr");
1353

A
aliguori 已提交
1354
    memory_dump(mon, count, format, size, addr, 1);
1355 1356
}

1357
static void do_print(Monitor *mon, const QDict *qdict)
1358
{
1359
    int format = qdict_get_int(qdict, "format");
A
Anthony Liguori 已提交
1360
    target_phys_addr_t val = qdict_get_int(qdict, "val");
1361

1362
#if TARGET_PHYS_ADDR_BITS == 32
1363 1364
    switch(format) {
    case 'o':
A
aliguori 已提交
1365
        monitor_printf(mon, "%#o", val);
1366 1367
        break;
    case 'x':
A
aliguori 已提交
1368
        monitor_printf(mon, "%#x", val);
1369 1370
        break;
    case 'u':
A
aliguori 已提交
1371
        monitor_printf(mon, "%u", val);
1372 1373 1374
        break;
    default:
    case 'd':
A
aliguori 已提交
1375
        monitor_printf(mon, "%d", val);
1376 1377
        break;
    case 'c':
A
aliguori 已提交
1378
        monitor_printc(mon, val);
1379 1380
        break;
    }
B
bellard 已提交
1381 1382 1383
#else
    switch(format) {
    case 'o':
A
aliguori 已提交
1384
        monitor_printf(mon, "%#" PRIo64, val);
B
bellard 已提交
1385 1386
        break;
    case 'x':
A
aliguori 已提交
1387
        monitor_printf(mon, "%#" PRIx64, val);
B
bellard 已提交
1388 1389
        break;
    case 'u':
A
aliguori 已提交
1390
        monitor_printf(mon, "%" PRIu64, val);
B
bellard 已提交
1391 1392 1393
        break;
    default:
    case 'd':
A
aliguori 已提交
1394
        monitor_printf(mon, "%" PRId64, val);
B
bellard 已提交
1395 1396
        break;
    case 'c':
A
aliguori 已提交
1397
        monitor_printc(mon, val);
B
bellard 已提交
1398 1399 1400
        break;
    }
#endif
A
aliguori 已提交
1401
    monitor_printf(mon, "\n");
1402 1403
}

1404
static void do_memory_save(Monitor *mon, const QDict *qdict, QObject **ret_data)
B
bellard 已提交
1405 1406
{
    FILE *f;
1407 1408 1409
    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 已提交
1410 1411 1412 1413 1414 1415 1416 1417
    uint32_t l;
    CPUState *env;
    uint8_t buf[1024];

    env = mon_get_cpu();

    f = fopen(filename, "wb");
    if (!f) {
1418
        qemu_error_new(QERR_OPEN_FILE_FAILED, filename);
B
bellard 已提交
1419 1420 1421 1422 1423 1424 1425
        return;
    }
    while (size != 0) {
        l = sizeof(buf);
        if (l > size)
            l = size;
        cpu_memory_rw_debug(env, addr, buf, l, 0);
1426 1427 1428 1429
        if (fwrite(buf, 1, l, f) != l) {
            monitor_printf(mon, "fwrite() error in do_memory_save\n");
            goto exit;
        }
B
bellard 已提交
1430 1431 1432
        addr += l;
        size -= l;
    }
1433
exit:
B
bellard 已提交
1434 1435 1436
    fclose(f);
}

1437 1438
static void do_physical_memory_save(Monitor *mon, const QDict *qdict,
                                    QObject **ret_data)
A
aurel32 已提交
1439 1440 1441 1442
{
    FILE *f;
    uint32_t l;
    uint8_t buf[1024];
1443 1444
    uint32_t size = qdict_get_int(qdict, "size");
    const char *filename = qdict_get_str(qdict, "filename");
A
Anthony Liguori 已提交
1445
    target_phys_addr_t addr = qdict_get_int(qdict, "val");
A
aurel32 已提交
1446 1447 1448

    f = fopen(filename, "wb");
    if (!f) {
1449
        qemu_error_new(QERR_OPEN_FILE_FAILED, filename);
A
aurel32 已提交
1450 1451 1452 1453 1454 1455 1456
        return;
    }
    while (size != 0) {
        l = sizeof(buf);
        if (l > size)
            l = size;
        cpu_physical_memory_rw(addr, buf, l, 0);
1457 1458 1459 1460
        if (fwrite(buf, 1, l, f) != l) {
            monitor_printf(mon, "fwrite() error in do_physical_memory_save\n");
            goto exit;
        }
A
aurel32 已提交
1461 1462 1463 1464
        fflush(f);
        addr += l;
        size -= l;
    }
1465
exit:
A
aurel32 已提交
1466 1467 1468
    fclose(f);
}

1469
static void do_sum(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1470 1471 1472 1473
{
    uint32_t addr;
    uint8_t buf[1];
    uint16_t sum;
1474 1475
    uint32_t start = qdict_get_int(qdict, "start");
    uint32_t size = qdict_get_int(qdict, "size");
B
bellard 已提交
1476 1477 1478 1479 1480 1481 1482 1483

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

B
bellard 已提交
1487 1488 1489 1490 1491 1492 1493 1494
typedef struct {
    int keycode;
    const char *name;
} KeyDef;

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

B
bellard 已提交
1496 1497
    { 0x38, "alt" },
    { 0xb8, "alt_r" },
1498 1499
    { 0x64, "altgr" },
    { 0xe4, "altgr_r" },
B
bellard 已提交
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
    { 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" },
1517 1518
    { 0x0c, "minus" },
    { 0x0d, "equal" },
B
bellard 已提交
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551
    { 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" },
1552 1553 1554
    { 0x33, "comma" },
    { 0x34, "dot" },
    { 0x35, "slash" },
1555

B
balrog 已提交
1556 1557
    { 0x37, "asterisk" },

B
bellard 已提交
1558
    { 0x39, "spc" },
B
bellard 已提交
1559
    { 0x3a, "caps_lock" },
B
bellard 已提交
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
    { 0x3b, "f1" },
    { 0x3c, "f2" },
    { 0x3d, "f3" },
    { 0x3e, "f4" },
    { 0x3f, "f5" },
    { 0x40, "f6" },
    { 0x41, "f7" },
    { 0x42, "f8" },
    { 0x43, "f9" },
    { 0x44, "f10" },
B
bellard 已提交
1570
    { 0x45, "num_lock" },
B
bellard 已提交
1571 1572
    { 0x46, "scroll_lock" },

1573 1574
    { 0xb5, "kp_divide" },
    { 0x37, "kp_multiply" },
T
ths 已提交
1575
    { 0x4a, "kp_subtract" },
1576 1577 1578
    { 0x4e, "kp_add" },
    { 0x9c, "kp_enter" },
    { 0x53, "kp_decimal" },
1579
    { 0x54, "sysrq" },
1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590

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

B
bellard 已提交
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610
    { 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" },
1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
#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 已提交
1628 1629 1630 1631 1632 1633
    { 0, NULL },
};

static int get_keycode(const char *key)
{
    const KeyDef *p;
1634 1635
    char *endp;
    int ret;
B
bellard 已提交
1636 1637 1638 1639 1640

    for(p = key_defs; p->name != NULL; p++) {
        if (!strcmp(key, p->name))
            return p->keycode;
    }
1641 1642 1643 1644 1645
    if (strstart(key, "0x", NULL)) {
        ret = strtoul(key, &endp, 0);
        if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
            return ret;
    }
B
bellard 已提交
1646 1647 1648
    return -1;
}

1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
#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);
    }
}

1667
static void do_sendkey(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1668
{
1669 1670 1671
    char keyname_buf[16];
    char *separator;
    int keyname_len, keycode, i;
1672 1673 1674
    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);
1675

1676 1677 1678 1679 1680 1681 1682
    if (nb_pending_keycodes > 0) {
        qemu_del_timer(key_timer);
        release_keys(NULL);
    }
    if (!has_hold_time)
        hold_time = 100;
    i = 0;
1683 1684 1685 1686 1687 1688
    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 已提交
1689
                monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1690
                return;
B
bellard 已提交
1691
            }
1692
            if (i == MAX_KEYCODES) {
A
aliguori 已提交
1693
                monitor_printf(mon, "too many keys\n");
1694 1695 1696 1697 1698
                return;
            }
            keyname_buf[keyname_len] = 0;
            keycode = get_keycode(keyname_buf);
            if (keycode < 0) {
A
aliguori 已提交
1699
                monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1700 1701
                return;
            }
1702
            keycodes[i++] = keycode;
B
bellard 已提交
1703
        }
1704
        if (!separator)
B
bellard 已提交
1705
            break;
1706
        string = separator + 1;
B
bellard 已提交
1707
    }
1708
    nb_pending_keycodes = i;
B
bellard 已提交
1709
    /* key down events */
1710
    for (i = 0; i < nb_pending_keycodes; i++) {
B
bellard 已提交
1711 1712 1713 1714 1715
        keycode = keycodes[i];
        if (keycode & 0x80)
            kbd_put_keycode(0xe0);
        kbd_put_keycode(keycode & 0x7f);
    }
1716
    /* delayed key up events */
1717
    qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
1718
                   muldiv64(get_ticks_per_sec(), hold_time, 1000));
B
bellard 已提交
1719 1720
}

B
bellard 已提交
1721 1722
static int mouse_button_state;

1723
static void do_mouse_move(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1724 1725
{
    int dx, dy, dz;
1726 1727 1728
    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 已提交
1729 1730 1731
    dx = strtol(dx_str, NULL, 0);
    dy = strtol(dy_str, NULL, 0);
    dz = 0;
1732
    if (dz_str)
B
bellard 已提交
1733 1734 1735 1736
        dz = strtol(dz_str, NULL, 0);
    kbd_mouse_event(dx, dy, dz, mouse_button_state);
}

1737
static void do_mouse_button(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1738
{
1739
    int button_state = qdict_get_int(qdict, "button_state");
B
bellard 已提交
1740 1741 1742 1743
    mouse_button_state = button_state;
    kbd_mouse_event(0, 0, 0, mouse_button_state);
}

1744
static void do_ioport_read(Monitor *mon, const QDict *qdict)
B
bellard 已提交
1745
{
1746 1747 1748
    int size = qdict_get_int(qdict, "size");
    int addr = qdict_get_int(qdict, "addr");
    int has_index = qdict_haskey(qdict, "index");
B
bellard 已提交
1749 1750 1751 1752
    uint32_t val;
    int suffix;

    if (has_index) {
1753
        int index = qdict_get_int(qdict, "index");
1754
        cpu_outb(addr & IOPORTS_MASK, index & 0xff);
B
bellard 已提交
1755 1756 1757 1758 1759 1760 1761
        addr++;
    }
    addr &= 0xffff;

    switch(size) {
    default:
    case 1:
1762
        val = cpu_inb(addr);
B
bellard 已提交
1763 1764 1765
        suffix = 'b';
        break;
    case 2:
1766
        val = cpu_inw(addr);
B
bellard 已提交
1767 1768 1769
        suffix = 'w';
        break;
    case 4:
1770
        val = cpu_inl(addr);
B
bellard 已提交
1771 1772 1773
        suffix = 'l';
        break;
    }
A
aliguori 已提交
1774 1775
    monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
                   suffix, addr, size * 2, val);
B
bellard 已提交
1776
}
B
bellard 已提交
1777

1778
static void do_ioport_write(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
1779
{
1780 1781 1782 1783
    int size = qdict_get_int(qdict, "size");
    int addr = qdict_get_int(qdict, "addr");
    int val = qdict_get_int(qdict, "val");

J
Jan Kiszka 已提交
1784 1785 1786 1787 1788
    addr &= IOPORTS_MASK;

    switch (size) {
    default:
    case 1:
1789
        cpu_outb(addr, val);
J
Jan Kiszka 已提交
1790 1791
        break;
    case 2:
1792
        cpu_outw(addr, val);
J
Jan Kiszka 已提交
1793 1794
        break;
    case 4:
1795
        cpu_outl(addr, val);
J
Jan Kiszka 已提交
1796 1797 1798 1799
        break;
    }
}

1800
static void do_boot_set(Monitor *mon, const QDict *qdict)
1801 1802
{
    int res;
1803
    const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1804

J
Jan Kiszka 已提交
1805 1806 1807 1808 1809
    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");
1810
    } else {
A
aliguori 已提交
1811 1812
        monitor_printf(mon, "no function defined to set boot device list for "
                       "this architecture\n");
1813 1814 1815
    }
}

1816 1817 1818 1819 1820
/**
 * do_system_reset(): Issue a machine reset
 */
static void do_system_reset(Monitor *mon, const QDict *qdict,
                            QObject **ret_data)
B
bellard 已提交
1821 1822 1823 1824
{
    qemu_system_reset_request();
}

1825 1826 1827 1828 1829
/**
 * do_system_powerdown(): Issue a machine powerdown
 */
static void do_system_powerdown(Monitor *mon, const QDict *qdict,
                                QObject **ret_data)
B
bellard 已提交
1830 1831 1832 1833
{
    qemu_system_powerdown_request();
}

B
bellard 已提交
1834
#if defined(TARGET_I386)
A
aliguori 已提交
1835
static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
B
bellard 已提交
1836
{
A
aliguori 已提交
1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847
    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 已提交
1848 1849
}

A
aliguori 已提交
1850
static void tlb_info(Monitor *mon)
B
bellard 已提交
1851
{
B
bellard 已提交
1852
    CPUState *env;
B
bellard 已提交
1853 1854 1855
    int l1, l2;
    uint32_t pgd, pde, pte;

B
bellard 已提交
1856 1857
    env = mon_get_cpu();

B
bellard 已提交
1858
    if (!(env->cr[0] & CR0_PG_MASK)) {
A
aliguori 已提交
1859
        monitor_printf(mon, "PG disabled\n");
B
bellard 已提交
1860 1861 1862 1863 1864 1865 1866 1867
        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 已提交
1868
                print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
B
bellard 已提交
1869 1870
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1871
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
B
bellard 已提交
1872 1873 1874
                                             (uint8_t *)&pte, 4);
                    pte = le32_to_cpu(pte);
                    if (pte & PG_PRESENT_MASK) {
A
aliguori 已提交
1875
                        print_pte(mon, (l1 << 22) + (l2 << 12),
1876
                                  pte & ~PG_PSE_MASK,
B
bellard 已提交
1877 1878 1879 1880 1881 1882 1883 1884
                                  ~0xfff);
                    }
                }
            }
        }
    }
}

A
aliguori 已提交
1885
static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
B
bellard 已提交
1886 1887
                      uint32_t end, int prot)
{
B
bellard 已提交
1888 1889 1890
    int prot1;
    prot1 = *plast_prot;
    if (prot != prot1) {
B
bellard 已提交
1891
        if (*pstart != -1) {
A
aliguori 已提交
1892 1893 1894 1895 1896
            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 已提交
1897 1898 1899 1900 1901 1902 1903 1904 1905
        }
        if (prot != 0)
            *pstart = end;
        else
            *pstart = -1;
        *plast_prot = prot;
    }
}

A
aliguori 已提交
1906
static void mem_info(Monitor *mon)
B
bellard 已提交
1907
{
B
bellard 已提交
1908
    CPUState *env;
B
bellard 已提交
1909 1910 1911
    int l1, l2, prot, last_prot;
    uint32_t pgd, pde, pte, start, end;

B
bellard 已提交
1912 1913
    env = mon_get_cpu();

B
bellard 已提交
1914
    if (!(env->cr[0] & CR0_PG_MASK)) {
A
aliguori 已提交
1915
        monitor_printf(mon, "PG disabled\n");
B
bellard 已提交
1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927
        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 已提交
1928
                mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1929 1930
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1931
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
B
bellard 已提交
1932 1933 1934 1935 1936 1937 1938 1939
                                             (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 已提交
1940
                    mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1941 1942 1943 1944
                }
            }
        } else {
            prot = 0;
A
aliguori 已提交
1945
            mem_print(mon, &start, &last_prot, end, prot);
B
bellard 已提交
1946 1947 1948 1949 1950
        }
    }
}
#endif

A
aurel32 已提交
1951 1952
#if defined(TARGET_SH4)

A
aliguori 已提交
1953
static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
A
aurel32 已提交
1954
{
A
aliguori 已提交
1955 1956 1957 1958 1959 1960 1961 1962
    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 已提交
1963 1964
}

A
aliguori 已提交
1965
static void tlb_info(Monitor *mon)
A
aurel32 已提交
1966 1967 1968 1969
{
    CPUState *env = mon_get_cpu();
    int i;

A
aliguori 已提交
1970
    monitor_printf (mon, "ITLB:\n");
A
aurel32 已提交
1971
    for (i = 0 ; i < ITLB_SIZE ; i++)
A
aliguori 已提交
1972 1973
        print_tlb (mon, i, &env->itlb[i]);
    monitor_printf (mon, "UTLB:\n");
A
aurel32 已提交
1974
    for (i = 0 ; i < UTLB_SIZE ; i++)
A
aliguori 已提交
1975
        print_tlb (mon, i, &env->utlb[i]);
A
aurel32 已提交
1976 1977 1978 1979
}

#endif

1980
static void do_info_kvm_print(Monitor *mon, const QObject *data)
A
aliguori 已提交
1981
{
1982 1983 1984 1985
    QDict *qdict;

    qdict = qobject_to_qdict(data);

A
aliguori 已提交
1986
    monitor_printf(mon, "kvm support: ");
1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011
    if (qdict_get_bool(qdict, "present")) {
        monitor_printf(mon, "%s\n", qdict_get_bool(qdict, "enabled") ?
                                    "enabled" : "disabled");
    } else {
        monitor_printf(mon, "not compiled\n");
    }
}

/**
 * do_info_kvm(): Show KVM information
 *
 * Return a QDict with the following information:
 *
 * - "enabled": true if KVM support is enabled, false otherwise
 * - "present": true if QEMU has KVM support, false otherwise
 *
 * Example:
 *
 * { "enabled": true, "present": true }
 */
static void do_info_kvm(Monitor *mon, QObject **ret_data)
{
#ifdef CONFIG_KVM
    *ret_data = qobject_from_jsonf("{ 'enabled': %i, 'present': true }",
                                   kvm_enabled());
A
aliguori 已提交
2012
#else
2013
    *ret_data = qobject_from_jsonf("{ 'enabled': false, 'present': false }");
A
aliguori 已提交
2014 2015 2016
#endif
}

2017 2018
static void do_info_numa(Monitor *mon)
{
2019
    int i;
2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035
    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 已提交
2036 2037
#ifdef CONFIG_PROFILER

A
Aurelien Jarno 已提交
2038 2039 2040
int64_t qemu_time;
int64_t dev_time;

A
aliguori 已提交
2041
static void do_info_profile(Monitor *mon)
B
bellard 已提交
2042 2043 2044 2045 2046
{
    int64_t total;
    total = qemu_time;
    if (total == 0)
        total = 1;
A
aliguori 已提交
2047
    monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
2048
                   dev_time, dev_time / (double)get_ticks_per_sec());
A
aliguori 已提交
2049
    monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
2050
                   qemu_time, qemu_time / (double)get_ticks_per_sec());
B
bellard 已提交
2051 2052 2053 2054
    qemu_time = 0;
    dev_time = 0;
}
#else
A
aliguori 已提交
2055
static void do_info_profile(Monitor *mon)
B
bellard 已提交
2056
{
A
aliguori 已提交
2057
    monitor_printf(mon, "Internal profiler not compiled\n");
B
bellard 已提交
2058 2059 2060
}
#endif

B
bellard 已提交
2061
/* Capture support */
B
Blue Swirl 已提交
2062
static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
B
bellard 已提交
2063

A
aliguori 已提交
2064
static void do_info_capture(Monitor *mon)
B
bellard 已提交
2065 2066 2067 2068 2069
{
    int i;
    CaptureState *s;

    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
A
aliguori 已提交
2070
        monitor_printf(mon, "[%d]: ", i);
B
bellard 已提交
2071 2072 2073 2074
        s->ops.info (s->opaque);
    }
}

2075
#ifdef HAS_AUDIO
2076
static void do_stop_capture(Monitor *mon, const QDict *qdict)
B
bellard 已提交
2077 2078
{
    int i;
2079
    int n = qdict_get_int(qdict, "n");
B
bellard 已提交
2080 2081 2082 2083 2084
    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);
B
Blue Swirl 已提交
2085
            QLIST_REMOVE (s, entries);
B
bellard 已提交
2086 2087 2088 2089 2090 2091
            qemu_free (s);
            return;
        }
    }
}

2092 2093 2094 2095 2096 2097 2098 2099 2100
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 已提交
2101 2102 2103 2104 2105 2106 2107 2108 2109
    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 已提交
2110
        monitor_printf(mon, "Faied to add wave capture\n");
B
bellard 已提交
2111 2112
        qemu_free (s);
    }
B
Blue Swirl 已提交
2113
    QLIST_INSERT_HEAD (&capture_head, s, entries);
B
bellard 已提交
2114 2115 2116
}
#endif

A
aurel32 已提交
2117
#if defined(TARGET_I386)
2118
static void do_inject_nmi(Monitor *mon, const QDict *qdict)
A
aurel32 已提交
2119 2120
{
    CPUState *env;
2121
    int cpu_index = qdict_get_int(qdict, "cpu_index");
A
aurel32 已提交
2122 2123 2124 2125 2126 2127 2128 2129 2130

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

2131
static void do_info_status_print(Monitor *mon, const QObject *data)
A
aurel32 已提交
2132
{
2133 2134 2135 2136 2137 2138 2139 2140 2141
    QDict *qdict;

    qdict = qobject_to_qdict(data);

    monitor_printf(mon, "VM status: ");
    if (qdict_get_bool(qdict, "running")) {
        monitor_printf(mon, "running");
        if (qdict_get_bool(qdict, "singlestep")) {
            monitor_printf(mon, " (single step mode)");
2142
        }
2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
    } else {
        monitor_printf(mon, "paused");
    }

    monitor_printf(mon, "\n");
}

/**
 * do_info_status(): VM status
 *
 * Return a QDict with the following information:
 *
 * - "running": true if the VM is running, or false if it is paused
 * - "singlestep": true if the VM is in single step mode, false otherwise
 *
 * Example:
 *
 * { "running": true, "singlestep": false }
 */
static void do_info_status(Monitor *mon, QObject **ret_data)
{
    *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
                                    vm_running, singlestep);
A
aurel32 已提交
2166 2167
}

2168
static void print_balloon_stat(const char *key, QObject *obj, void *opaque)
2169
{
2170
    Monitor *mon = opaque;
2171

2172 2173 2174
    if (strcmp(key, "actual"))
        monitor_printf(mon, ",%s=%" PRId64, key,
                       qint_get_int(qobject_to_qint(obj)));
A
aliguori 已提交
2175 2176
}

2177 2178
static void monitor_print_balloon(Monitor *mon, const QObject *data)
{
2179 2180 2181
    QDict *qdict;

    qdict = qobject_to_qdict(data);
2182 2183
    if (!qdict_haskey(qdict, "actual"))
        return;
2184

2185 2186 2187 2188
    monitor_printf(mon, "balloon: actual=%" PRId64,
                   qdict_get_int(qdict, "actual") >> 20);
    qdict_iter(qdict, print_balloon_stat, mon);
    monitor_printf(mon, "\n");
2189 2190 2191 2192
}

/**
 * do_info_balloon(): Balloon information
2193
 *
2194 2195
 * Make an asynchronous request for balloon info.  When the request completes
 * a QDict will be returned according to the following specification:
2196
 *
2197 2198 2199 2200 2201 2202 2203 2204
 * - "actual": current balloon value in bytes
 * The following fields may or may not be present:
 * - "mem_swapped_in": Amount of memory swapped in (bytes)
 * - "mem_swapped_out": Amount of memory swapped out (bytes)
 * - "major_page_faults": Number of major faults
 * - "minor_page_faults": Number of minor faults
 * - "free_mem": Total amount of free and unused memory (bytes)
 * - "total_mem": Total amount of available memory (bytes)
2205 2206 2207
 *
 * Example:
 *
2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
 * { "actual": 1073741824, "mem_swapped_in": 0, "mem_swapped_out": 0,
 *   "major_page_faults": 142, "minor_page_faults": 239245,
 *   "free_mem": 1014185984, "total_mem": 1044668416 }
 */
static int do_info_balloon(Monitor *mon, MonitorCompletion cb, void *opaque)
{
    int ret;

    if (kvm_enabled() && !kvm_has_sync_mmu()) {
        qemu_error_new(QERR_KVM_MISSING_CAP, "synchronous MMU", "balloon");
        return -1;
    }

    ret = qemu_balloon_status(cb, opaque);
    if (!ret) {
        qemu_error_new(QERR_DEVICE_NOT_ACTIVE, "balloon");
        return -1;
    }

    return 0;
}

/**
 * do_balloon(): Request VM to change its memory allocation
2232
 */
2233 2234
static int do_balloon(Monitor *mon, const QDict *params,
                       MonitorCompletion cb, void *opaque)
A
aliguori 已提交
2235
{
2236
    int ret;
A
aliguori 已提交
2237

2238 2239 2240
    if (kvm_enabled() && !kvm_has_sync_mmu()) {
        qemu_error_new(QERR_KVM_MISSING_CAP, "synchronous MMU", "balloon");
        return -1;
2241
    }
2242 2243 2244 2245 2246 2247 2248 2249

    ret = qemu_balloon(qdict_get_int(params, "value"), cb, opaque);
    if (ret == 0) {
        qemu_error_new(QERR_DEVICE_NOT_ACTIVE, "balloon");
        return -1;
    }

    return 0;
A
aliguori 已提交
2250 2251
}

J
Jan Kiszka 已提交
2252
static qemu_acl *find_acl(Monitor *mon, const char *name)
2253
{
J
Jan Kiszka 已提交
2254
    qemu_acl *acl = qemu_acl_find(name);
2255 2256

    if (!acl) {
J
Jan Kiszka 已提交
2257
        monitor_printf(mon, "acl: unknown list '%s'\n", name);
2258
    }
J
Jan Kiszka 已提交
2259 2260 2261
    return acl;
}

2262
static void do_acl_show(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
2263
{
2264
    const char *aclname = qdict_get_str(qdict, "aclname");
J
Jan Kiszka 已提交
2265 2266 2267
    qemu_acl *acl = find_acl(mon, aclname);
    qemu_acl_entry *entry;
    int i = 0;
2268

J
Jan Kiszka 已提交
2269
    if (acl) {
2270
        monitor_printf(mon, "policy: %s\n",
2271
                       acl->defaultDeny ? "deny" : "allow");
B
Blue Swirl 已提交
2272
        QTAILQ_FOREACH(entry, &acl->entries, next) {
2273 2274
            i++;
            monitor_printf(mon, "%d: %s %s\n", i,
J
Jan Kiszka 已提交
2275
                           entry->deny ? "deny" : "allow", entry->match);
2276
        }
J
Jan Kiszka 已提交
2277 2278 2279
    }
}

2280
static void do_acl_reset(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
2281
{
2282
    const char *aclname = qdict_get_str(qdict, "aclname");
J
Jan Kiszka 已提交
2283 2284 2285
    qemu_acl *acl = find_acl(mon, aclname);

    if (acl) {
2286 2287
        qemu_acl_reset(acl);
        monitor_printf(mon, "acl: removed all rules\n");
J
Jan Kiszka 已提交
2288 2289 2290
    }
}

2291
static void do_acl_policy(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
2292
{
2293 2294
    const char *aclname = qdict_get_str(qdict, "aclname");
    const char *policy = qdict_get_str(qdict, "policy");
J
Jan Kiszka 已提交
2295
    qemu_acl *acl = find_acl(mon, aclname);
2296

J
Jan Kiszka 已提交
2297 2298
    if (acl) {
        if (strcmp(policy, "allow") == 0) {
2299 2300
            acl->defaultDeny = 0;
            monitor_printf(mon, "acl: policy set to 'allow'\n");
J
Jan Kiszka 已提交
2301
        } else if (strcmp(policy, "deny") == 0) {
2302 2303 2304
            acl->defaultDeny = 1;
            monitor_printf(mon, "acl: policy set to 'deny'\n");
        } else {
J
Jan Kiszka 已提交
2305 2306
            monitor_printf(mon, "acl: unknown policy '%s', "
                           "expected 'deny' or 'allow'\n", policy);
2307
        }
J
Jan Kiszka 已提交
2308 2309
    }
}
2310

2311
static void do_acl_add(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
2312
{
2313 2314 2315 2316 2317
    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 已提交
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328
    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);
2329 2330 2331 2332 2333 2334 2335 2336 2337 2338
            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 已提交
2339 2340
    }
}
2341

2342
static void do_acl_remove(Monitor *mon, const QDict *qdict)
J
Jan Kiszka 已提交
2343
{
2344 2345
    const char *aclname = qdict_get_str(qdict, "aclname");
    const char *match = qdict_get_str(qdict, "match");
J
Jan Kiszka 已提交
2346 2347
    qemu_acl *acl = find_acl(mon, aclname);
    int ret;
2348

J
Jan Kiszka 已提交
2349
    if (acl) {
2350 2351 2352 2353 2354
        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);
2355 2356 2357
    }
}

2358
#if defined(TARGET_I386)
2359
static void do_inject_mce(Monitor *mon, const QDict *qdict)
2360 2361
{
    CPUState *cenv;
2362 2363 2364 2365 2366 2367
    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");
2368 2369 2370 2371 2372 2373 2374 2375 2376

    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

2377
static void do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2378
{
2379
    const char *fdname = qdict_get_str(qdict, "fdname");
A
Anthony Liguori 已提交
2380
    mon_fd_t *monfd;
2381 2382 2383 2384
    int fd;

    fd = qemu_chr_get_msgfd(mon->chr);
    if (fd == -1) {
2385
        qemu_error_new(QERR_FD_NOT_SUPPLIED);
2386 2387 2388 2389
        return;
    }

    if (qemu_isdigit(fdname[0])) {
2390
        qemu_error_new(QERR_INVALID_PARAMETER, "fdname");
2391 2392 2393 2394 2395
        return;
    }

    fd = dup(fd);
    if (fd == -1) {
2396 2397 2398 2399
        if (errno == EMFILE)
            qemu_error_new(QERR_TOO_MANY_FILES);
        else
            qemu_error_new(QERR_UNDEFINED_ERROR);
2400 2401 2402
        return;
    }

B
Blue Swirl 已提交
2403
    QLIST_FOREACH(monfd, &mon->fds, next) {
2404 2405 2406 2407 2408 2409 2410 2411 2412
        if (strcmp(monfd->name, fdname) != 0) {
            continue;
        }

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

A
Anthony Liguori 已提交
2413
    monfd = qemu_mallocz(sizeof(mon_fd_t));
2414 2415 2416
    monfd->name = qemu_strdup(fdname);
    monfd->fd = fd;

B
Blue Swirl 已提交
2417
    QLIST_INSERT_HEAD(&mon->fds, monfd, next);
2418 2419
}

2420
static void do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2421
{
2422
    const char *fdname = qdict_get_str(qdict, "fdname");
A
Anthony Liguori 已提交
2423
    mon_fd_t *monfd;
2424

B
Blue Swirl 已提交
2425
    QLIST_FOREACH(monfd, &mon->fds, next) {
2426 2427 2428 2429
        if (strcmp(monfd->name, fdname) != 0) {
            continue;
        }

B
Blue Swirl 已提交
2430
        QLIST_REMOVE(monfd, next);
2431 2432 2433 2434 2435 2436
        close(monfd->fd);
        qemu_free(monfd->name);
        qemu_free(monfd);
        return;
    }

2437
    qemu_error_new(QERR_FD_NOT_FOUND, fdname);
2438 2439
}

2440
static void do_loadvm(Monitor *mon, const QDict *qdict)
J
Juan Quintela 已提交
2441 2442
{
    int saved_vm_running  = vm_running;
2443
    const char *name = qdict_get_str(qdict, "name");
J
Juan Quintela 已提交
2444 2445 2446

    vm_stop(0);

2447
    if (load_vmstate(mon, name) >= 0 && saved_vm_running)
J
Juan Quintela 已提交
2448 2449 2450
        vm_start();
}

2451 2452
int monitor_get_fd(Monitor *mon, const char *fdname)
{
A
Anthony Liguori 已提交
2453
    mon_fd_t *monfd;
2454

B
Blue Swirl 已提交
2455
    QLIST_FOREACH(monfd, &mon->fds, next) {
2456 2457 2458 2459 2460 2461 2462 2463 2464
        int fd;

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

        fd = monfd->fd;

        /* caller takes ownership of fd */
B
Blue Swirl 已提交
2465
        QLIST_REMOVE(monfd, next);
2466 2467 2468 2469 2470 2471 2472 2473 2474
        qemu_free(monfd->name);
        qemu_free(monfd);

        return fd;
    }

    return -1;
}

A
Anthony Liguori 已提交
2475
static const mon_cmd_t mon_cmds[] = {
2476
#include "qemu-monitor.h"
2477
    { NULL, NULL, },
B
bellard 已提交
2478 2479
};

2480
/* Please update qemu-monitor.hx when adding or changing commands */
A
Anthony Liguori 已提交
2481
static const mon_cmd_t info_cmds[] = {
2482 2483 2484 2485 2486
    {
        .name       = "version",
        .args_type  = "",
        .params     = "",
        .help       = "show the version of QEMU",
2487
        .user_print = do_info_version_print,
2488
        .mhandler.info_new = do_info_version,
2489
    },
2490 2491 2492 2493 2494 2495 2496 2497
    {
        .name       = "commands",
        .args_type  = "",
        .params     = "",
        .help       = "list QMP available commands",
        .user_print = monitor_user_noop,
        .mhandler.info_new = do_info_commands,
    },
2498 2499 2500 2501 2502
    {
        .name       = "network",
        .args_type  = "",
        .params     = "",
        .help       = "show the network state",
L
Luiz Capitulino 已提交
2503
        .mhandler.info = do_info_network,
2504 2505 2506 2507 2508 2509
    },
    {
        .name       = "chardev",
        .args_type  = "",
        .params     = "",
        .help       = "show the character devices",
2510 2511
        .user_print = qemu_chr_info_print,
        .mhandler.info_new = qemu_chr_info,
2512 2513 2514 2515 2516 2517
    },
    {
        .name       = "block",
        .args_type  = "",
        .params     = "",
        .help       = "show the block devices",
2518 2519
        .user_print = bdrv_info_print,
        .mhandler.info_new = bdrv_info,
2520 2521 2522 2523 2524 2525
    },
    {
        .name       = "blockstats",
        .args_type  = "",
        .params     = "",
        .help       = "show block device statistics",
2526 2527
        .user_print = bdrv_stats_print,
        .mhandler.info_new = bdrv_info_stats,
2528 2529 2530 2531 2532 2533
    },
    {
        .name       = "registers",
        .args_type  = "",
        .params     = "",
        .help       = "show the cpu registers",
L
Luiz Capitulino 已提交
2534
        .mhandler.info = do_info_registers,
2535 2536 2537 2538 2539 2540
    },
    {
        .name       = "cpus",
        .args_type  = "",
        .params     = "",
        .help       = "show infos for each CPU",
2541 2542
        .user_print = monitor_print_cpus,
        .mhandler.info_new = do_info_cpus,
2543 2544 2545 2546 2547 2548
    },
    {
        .name       = "history",
        .args_type  = "",
        .params     = "",
        .help       = "show the command line history",
L
Luiz Capitulino 已提交
2549
        .mhandler.info = do_info_history,
2550 2551 2552 2553 2554 2555
    },
    {
        .name       = "irq",
        .args_type  = "",
        .params     = "",
        .help       = "show the interrupts statistics (if available)",
L
Luiz Capitulino 已提交
2556
        .mhandler.info = irq_info,
2557 2558 2559 2560 2561 2562
    },
    {
        .name       = "pic",
        .args_type  = "",
        .params     = "",
        .help       = "show i8259 (PIC) state",
L
Luiz Capitulino 已提交
2563
        .mhandler.info = pic_info,
2564 2565 2566 2567 2568 2569
    },
    {
        .name       = "pci",
        .args_type  = "",
        .params     = "",
        .help       = "show PCI info",
2570 2571
        .user_print = do_pci_info_print,
        .mhandler.info_new = do_pci_info,
2572
    },
A
aurel32 已提交
2573
#if defined(TARGET_I386) || defined(TARGET_SH4)
2574 2575 2576 2577 2578
    {
        .name       = "tlb",
        .args_type  = "",
        .params     = "",
        .help       = "show virtual to physical memory mappings",
L
Luiz Capitulino 已提交
2579
        .mhandler.info = tlb_info,
2580
    },
A
aurel32 已提交
2581 2582
#endif
#if defined(TARGET_I386)
2583 2584 2585 2586 2587
    {
        .name       = "mem",
        .args_type  = "",
        .params     = "",
        .help       = "show the active virtual memory mappings",
L
Luiz Capitulino 已提交
2588
        .mhandler.info = mem_info,
2589 2590 2591 2592 2593 2594
    },
    {
        .name       = "hpet",
        .args_type  = "",
        .params     = "",
        .help       = "show state of HPET",
2595 2596
        .user_print = do_info_hpet_print,
        .mhandler.info_new = do_info_hpet,
2597
    },
B
bellard 已提交
2598
#endif
2599 2600 2601 2602 2603
    {
        .name       = "jit",
        .args_type  = "",
        .params     = "",
        .help       = "show dynamic compiler info",
L
Luiz Capitulino 已提交
2604
        .mhandler.info = do_info_jit,
2605 2606 2607 2608 2609 2610
    },
    {
        .name       = "kvm",
        .args_type  = "",
        .params     = "",
        .help       = "show KVM information",
2611 2612
        .user_print = do_info_kvm_print,
        .mhandler.info_new = do_info_kvm,
2613 2614 2615 2616 2617 2618
    },
    {
        .name       = "numa",
        .args_type  = "",
        .params     = "",
        .help       = "show NUMA information",
L
Luiz Capitulino 已提交
2619
        .mhandler.info = do_info_numa,
2620 2621 2622 2623 2624 2625
    },
    {
        .name       = "usb",
        .args_type  = "",
        .params     = "",
        .help       = "show guest USB devices",
L
Luiz Capitulino 已提交
2626
        .mhandler.info = usb_info,
2627 2628 2629 2630 2631 2632
    },
    {
        .name       = "usbhost",
        .args_type  = "",
        .params     = "",
        .help       = "show host USB devices",
L
Luiz Capitulino 已提交
2633
        .mhandler.info = usb_host_info,
2634 2635 2636 2637 2638 2639
    },
    {
        .name       = "profile",
        .args_type  = "",
        .params     = "",
        .help       = "show profiling information",
L
Luiz Capitulino 已提交
2640
        .mhandler.info = do_info_profile,
2641 2642 2643 2644 2645 2646
    },
    {
        .name       = "capture",
        .args_type  = "",
        .params     = "",
        .help       = "show capture information",
L
Luiz Capitulino 已提交
2647
        .mhandler.info = do_info_capture,
2648 2649 2650 2651 2652 2653
    },
    {
        .name       = "snapshots",
        .args_type  = "",
        .params     = "",
        .help       = "show the currently saved VM snapshots",
L
Luiz Capitulino 已提交
2654
        .mhandler.info = do_info_snapshots,
2655 2656 2657 2658 2659 2660
    },
    {
        .name       = "status",
        .args_type  = "",
        .params     = "",
        .help       = "show the current VM status (running|paused)",
2661 2662
        .user_print = do_info_status_print,
        .mhandler.info_new = do_info_status,
2663 2664 2665 2666 2667 2668
    },
    {
        .name       = "pcmcia",
        .args_type  = "",
        .params     = "",
        .help       = "show guest PCMCIA status",
L
Luiz Capitulino 已提交
2669
        .mhandler.info = pcmcia_info,
2670 2671 2672 2673 2674 2675
    },
    {
        .name       = "mice",
        .args_type  = "",
        .params     = "",
        .help       = "show which guest mouse is receiving events",
2676 2677
        .user_print = do_info_mice_print,
        .mhandler.info_new = do_info_mice,
2678 2679 2680 2681 2682 2683
    },
    {
        .name       = "vnc",
        .args_type  = "",
        .params     = "",
        .help       = "show the vnc server status",
2684 2685
        .user_print = do_info_vnc_print,
        .mhandler.info_new = do_info_vnc,
2686 2687 2688 2689 2690 2691
    },
    {
        .name       = "name",
        .args_type  = "",
        .params     = "",
        .help       = "show the current VM name",
2692 2693
        .user_print = do_info_name_print,
        .mhandler.info_new = do_info_name,
2694 2695 2696 2697 2698 2699
    },
    {
        .name       = "uuid",
        .args_type  = "",
        .params     = "",
        .help       = "show the current VM UUID",
2700 2701
        .user_print = do_info_uuid_print,
        .mhandler.info_new = do_info_uuid,
2702
    },
2703
#if defined(TARGET_PPC)
2704 2705 2706 2707 2708
    {
        .name       = "cpustats",
        .args_type  = "",
        .params     = "",
        .help       = "show CPU statistics",
L
Luiz Capitulino 已提交
2709
        .mhandler.info = do_info_cpu_stats,
2710
    },
2711
#endif
2712
#if defined(CONFIG_SLIRP)
2713 2714 2715 2716 2717
    {
        .name       = "usernet",
        .args_type  = "",
        .params     = "",
        .help       = "show user network stack connection states",
L
Luiz Capitulino 已提交
2718
        .mhandler.info = do_info_usernet,
2719
    },
2720
#endif
2721 2722 2723 2724 2725
    {
        .name       = "migrate",
        .args_type  = "",
        .params     = "",
        .help       = "show migration status",
2726 2727
        .user_print = do_info_migrate_print,
        .mhandler.info_new = do_info_migrate,
2728 2729 2730 2731 2732 2733
    },
    {
        .name       = "balloon",
        .args_type  = "",
        .params     = "",
        .help       = "show balloon information",
2734
        .user_print = monitor_print_balloon,
2735 2736
        .mhandler.info_async = do_info_balloon,
        .async      = 1,
2737 2738 2739 2740 2741 2742
    },
    {
        .name       = "qtree",
        .args_type  = "",
        .params     = "",
        .help       = "show device tree",
L
Luiz Capitulino 已提交
2743
        .mhandler.info = do_info_qtree,
2744 2745 2746 2747 2748 2749
    },
    {
        .name       = "qdm",
        .args_type  = "",
        .params     = "",
        .help       = "show qdev device model list",
L
Luiz Capitulino 已提交
2750
        .mhandler.info = do_info_qdm,
2751 2752 2753 2754 2755 2756
    },
    {
        .name       = "roms",
        .args_type  = "",
        .params     = "",
        .help       = "show roms",
L
Luiz Capitulino 已提交
2757
        .mhandler.info = do_info_roms,
2758 2759 2760 2761
    },
    {
        .name       = NULL,
    },
B
bellard 已提交
2762 2763
};

2764 2765 2766 2767 2768
/*******************************************************************/

static const char *pch;
static jmp_buf expr_env;

B
bellard 已提交
2769 2770 2771
#define MD_TLONG 0
#define MD_I32   1

2772 2773 2774
typedef struct MonitorDef {
    const char *name;
    int offset;
B
blueswir1 已提交
2775
    target_long (*get_value)(const struct MonitorDef *md, int val);
B
bellard 已提交
2776
    int type;
2777 2778
} MonitorDef;

B
bellard 已提交
2779
#if defined(TARGET_I386)
B
blueswir1 已提交
2780
static target_long monitor_get_pc (const struct MonitorDef *md, int val)
B
bellard 已提交
2781
{
B
bellard 已提交
2782 2783
    CPUState *env = mon_get_cpu();
    return env->eip + env->segs[R_CS].base;
B
bellard 已提交
2784 2785 2786
}
#endif

2787
#if defined(TARGET_PPC)
B
blueswir1 已提交
2788
static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
2789
{
B
bellard 已提交
2790
    CPUState *env = mon_get_cpu();
2791 2792 2793 2794 2795
    unsigned int u;
    int i;

    u = 0;
    for (i = 0; i < 8; i++)
2796
        u |= env->crf[i] << (32 - (4 * i));
2797 2798 2799 2800

    return u;
}

B
blueswir1 已提交
2801
static target_long monitor_get_msr (const struct MonitorDef *md, int val)
2802
{
B
bellard 已提交
2803
    CPUState *env = mon_get_cpu();
2804
    return env->msr;
2805 2806
}

B
blueswir1 已提交
2807
static target_long monitor_get_xer (const struct MonitorDef *md, int val)
2808
{
B
bellard 已提交
2809
    CPUState *env = mon_get_cpu();
A
aurel32 已提交
2810
    return env->xer;
2811
}
2812

B
blueswir1 已提交
2813
static target_long monitor_get_decr (const struct MonitorDef *md, int val)
2814
{
B
bellard 已提交
2815 2816
    CPUState *env = mon_get_cpu();
    return cpu_ppc_load_decr(env);
2817 2818
}

B
blueswir1 已提交
2819
static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
2820
{
B
bellard 已提交
2821 2822
    CPUState *env = mon_get_cpu();
    return cpu_ppc_load_tbu(env);
2823 2824
}

B
blueswir1 已提交
2825
static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
2826
{
B
bellard 已提交
2827 2828
    CPUState *env = mon_get_cpu();
    return cpu_ppc_load_tbl(env);
2829
}
2830 2831
#endif

2832
#if defined(TARGET_SPARC)
B
bellard 已提交
2833
#ifndef TARGET_SPARC64
B
blueswir1 已提交
2834
static target_long monitor_get_psr (const struct MonitorDef *md, int val)
2835
{
B
bellard 已提交
2836 2837
    CPUState *env = mon_get_cpu();
    return GET_PSR(env);
2838
}
B
bellard 已提交
2839
#endif
2840

B
blueswir1 已提交
2841
static target_long monitor_get_reg(const struct MonitorDef *md, int val)
2842
{
B
bellard 已提交
2843 2844
    CPUState *env = mon_get_cpu();
    return env->regwptr[val];
2845 2846 2847
}
#endif

B
blueswir1 已提交
2848
static const MonitorDef monitor_defs[] = {
2849
#ifdef TARGET_I386
B
bellard 已提交
2850 2851

#define SEG(name, seg) \
B
bellard 已提交
2852
    { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
B
bellard 已提交
2853
    { name ".base", offsetof(CPUState, segs[seg].base) },\
B
bellard 已提交
2854
    { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
B
bellard 已提交
2855

2856 2857 2858 2859 2860 2861 2862
    { "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 已提交
2863
    { "edi", offsetof(CPUState, regs[7]) },
B
bellard 已提交
2864 2865 2866 2867 2868 2869 2870 2871 2872 2873
#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
2874
    { "eflags", offsetof(CPUState, eflags) },
B
bellard 已提交
2875 2876 2877 2878
    { "eip", offsetof(CPUState, eip) },
    SEG("cs", R_CS)
    SEG("ds", R_DS)
    SEG("es", R_ES)
B
bellard 已提交
2879
    SEG("ss", R_SS)
B
bellard 已提交
2880 2881 2882
    SEG("fs", R_FS)
    SEG("gs", R_GS)
    { "pc", 0, monitor_get_pc, },
2883
#elif defined(TARGET_PPC)
J
j_mayer 已提交
2884
    /* General purpose registers */
2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916
    { "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 已提交
2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951
    /* 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 已提交
2952
    { "nip|pc", offsetof(CPUState, nip) },
2953 2954
    { "lr", offsetof(CPUState, lr) },
    { "ctr", offsetof(CPUState, ctr) },
2955
    { "decr", 0, &monitor_get_decr, },
2956
    { "ccr", 0, &monitor_get_ccr, },
J
j_mayer 已提交
2957
    /* Machine state register */
2958 2959
    { "msr", 0, &monitor_get_msr, },
    { "xer", 0, &monitor_get_xer, },
2960 2961
    { "tbu", 0, &monitor_get_tbu, },
    { "tbl", 0, &monitor_get_tbl, },
J
j_mayer 已提交
2962 2963 2964 2965 2966
#if defined(TARGET_PPC64)
    /* Address space register */
    { "asr", offsetof(CPUState, asr) },
#endif
    /* Segment registers */
2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984
    { "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 ... */
2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020
#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 已提交
3021
#ifndef TARGET_SPARC64
3022 3023
    { "psr", 0, &monitor_get_psr, },
    { "wim", offsetof(CPUState, wim) },
B
bellard 已提交
3024
#endif
3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058
    { "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 已提交
3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084
#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
3085 3086 3087 3088
#endif
    { NULL },
};

A
aliguori 已提交
3089
static void expr_error(Monitor *mon, const char *msg)
B
bellard 已提交
3090
{
A
aliguori 已提交
3091
    monitor_printf(mon, "%s\n", msg);
3092 3093 3094
    longjmp(expr_env, 1);
}

3095
/* return 0 if OK, -1 if not found */
B
bellard 已提交
3096
static int get_monitor_def(target_long *pval, const char *name)
3097
{
B
blueswir1 已提交
3098
    const MonitorDef *md;
B
bellard 已提交
3099 3100
    void *ptr;

3101 3102 3103
    for(md = monitor_defs; md->name != NULL; md++) {
        if (compare_cmd(name, md->name)) {
            if (md->get_value) {
3104
                *pval = md->get_value(md, md->offset);
3105
            } else {
B
bellard 已提交
3106 3107
                CPUState *env = mon_get_cpu();
                ptr = (uint8_t *)env + md->offset;
B
bellard 已提交
3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118
                switch(md->type) {
                case MD_I32:
                    *pval = *(int32_t *)ptr;
                    break;
                case MD_TLONG:
                    *pval = *(target_long *)ptr;
                    break;
                default:
                    *pval = 0;
                    break;
                }
3119 3120 3121 3122 3123 3124 3125 3126 3127
            }
            return 0;
        }
    }
    return -1;
}

static void next(void)
{
3128
    if (*pch != '\0') {
3129
        pch++;
3130
        while (qemu_isspace(*pch))
3131 3132 3133 3134
            pch++;
    }
}

A
aliguori 已提交
3135
static int64_t expr_sum(Monitor *mon);
3136

A
aliguori 已提交
3137
static int64_t expr_unary(Monitor *mon)
3138
{
B
blueswir1 已提交
3139
    int64_t n;
3140
    char *p;
B
bellard 已提交
3141
    int ret;
3142 3143 3144 3145

    switch(*pch) {
    case '+':
        next();
A
aliguori 已提交
3146
        n = expr_unary(mon);
3147 3148 3149
        break;
    case '-':
        next();
A
aliguori 已提交
3150
        n = -expr_unary(mon);
3151 3152 3153
        break;
    case '~':
        next();
A
aliguori 已提交
3154
        n = ~expr_unary(mon);
3155 3156 3157
        break;
    case '(':
        next();
A
aliguori 已提交
3158
        n = expr_sum(mon);
3159
        if (*pch != ')') {
A
aliguori 已提交
3160
            expr_error(mon, "')' expected");
3161 3162 3163
        }
        next();
        break;
B
bellard 已提交
3164 3165 3166
    case '\'':
        pch++;
        if (*pch == '\0')
A
aliguori 已提交
3167
            expr_error(mon, "character constant expected");
B
bellard 已提交
3168 3169 3170
        n = *pch;
        pch++;
        if (*pch != '\'')
A
aliguori 已提交
3171
            expr_error(mon, "missing terminating \' character");
B
bellard 已提交
3172 3173
        next();
        break;
3174 3175 3176
    case '$':
        {
            char buf[128], *q;
3177
            target_long reg=0;
3178

3179 3180 3181 3182 3183
            pch++;
            q = buf;
            while ((*pch >= 'a' && *pch <= 'z') ||
                   (*pch >= 'A' && *pch <= 'Z') ||
                   (*pch >= '0' && *pch <= '9') ||
B
bellard 已提交
3184
                   *pch == '_' || *pch == '.') {
3185 3186 3187 3188
                if ((q - buf) < sizeof(buf) - 1)
                    *q++ = *pch;
                pch++;
            }
3189
            while (qemu_isspace(*pch))
3190 3191
                pch++;
            *q = 0;
3192
            ret = get_monitor_def(&reg, buf);
3193
            if (ret < 0)
A
aliguori 已提交
3194
                expr_error(mon, "unknown register");
3195
            n = reg;
3196 3197 3198
        }
        break;
    case '\0':
A
aliguori 已提交
3199
        expr_error(mon, "unexpected end of expression");
3200 3201 3202
        n = 0;
        break;
    default:
3203
#if TARGET_PHYS_ADDR_BITS > 32
B
bellard 已提交
3204 3205
        n = strtoull(pch, &p, 0);
#else
3206
        n = strtoul(pch, &p, 0);
B
bellard 已提交
3207
#endif
3208
        if (pch == p) {
A
aliguori 已提交
3209
            expr_error(mon, "invalid char in expression");
3210 3211
        }
        pch = p;
3212
        while (qemu_isspace(*pch))
3213 3214 3215 3216 3217 3218 3219
            pch++;
        break;
    }
    return n;
}


A
aliguori 已提交
3220
static int64_t expr_prod(Monitor *mon)
3221
{
B
blueswir1 已提交
3222
    int64_t val, val2;
B
bellard 已提交
3223
    int op;
3224

A
aliguori 已提交
3225
    val = expr_unary(mon);
3226 3227 3228 3229 3230
    for(;;) {
        op = *pch;
        if (op != '*' && op != '/' && op != '%')
            break;
        next();
A
aliguori 已提交
3231
        val2 = expr_unary(mon);
3232 3233 3234 3235 3236 3237 3238
        switch(op) {
        default:
        case '*':
            val *= val2;
            break;
        case '/':
        case '%':
3239
            if (val2 == 0)
A
aliguori 已提交
3240
                expr_error(mon, "division by zero");
3241 3242 3243 3244 3245 3246 3247 3248 3249 3250
            if (op == '/')
                val /= val2;
            else
                val %= val2;
            break;
        }
    }
    return val;
}

A
aliguori 已提交
3251
static int64_t expr_logic(Monitor *mon)
3252
{
B
blueswir1 已提交
3253
    int64_t val, val2;
B
bellard 已提交
3254
    int op;
3255

A
aliguori 已提交
3256
    val = expr_prod(mon);
3257 3258 3259 3260 3261
    for(;;) {
        op = *pch;
        if (op != '&' && op != '|' && op != '^')
            break;
        next();
A
aliguori 已提交
3262
        val2 = expr_prod(mon);
3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278
        switch(op) {
        default:
        case '&':
            val &= val2;
            break;
        case '|':
            val |= val2;
            break;
        case '^':
            val ^= val2;
            break;
        }
    }
    return val;
}

A
aliguori 已提交
3279
static int64_t expr_sum(Monitor *mon)
3280
{
B
blueswir1 已提交
3281
    int64_t val, val2;
B
bellard 已提交
3282
    int op;
3283

A
aliguori 已提交
3284
    val = expr_logic(mon);
3285 3286 3287 3288 3289
    for(;;) {
        op = *pch;
        if (op != '+' && op != '-')
            break;
        next();
A
aliguori 已提交
3290
        val2 = expr_logic(mon);
3291 3292 3293 3294 3295 3296 3297 3298
        if (op == '+')
            val += val2;
        else
            val -= val2;
    }
    return val;
}

A
aliguori 已提交
3299
static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3300 3301 3302 3303 3304 3305
{
    pch = *pp;
    if (setjmp(expr_env)) {
        *pp = pch;
        return -1;
    }
3306
    while (qemu_isspace(*pch))
3307
        pch++;
A
aliguori 已提交
3308
    *pval = expr_sum(mon);
3309 3310 3311 3312
    *pp = pch;
    return 0;
}

3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333
static int get_double(Monitor *mon, double *pval, const char **pp)
{
    const char *p = *pp;
    char *tailp;
    double d;

    d = strtod(p, &tailp);
    if (tailp == p) {
        monitor_printf(mon, "Number expected\n");
        return -1;
    }
    if (d != d || d - d != 0) {
        /* NaN or infinity */
        monitor_printf(mon, "Bad number\n");
        return -1;
    }
    *pval = d;
    *pp = tailp;
    return 0;
}

3334 3335 3336 3337 3338 3339
static int get_str(char *buf, int buf_size, const char **pp)
{
    const char *p;
    char *q;
    int c;

B
bellard 已提交
3340
    q = buf;
3341
    p = *pp;
3342
    while (qemu_isspace(*p))
3343 3344 3345
        p++;
    if (*p == '\0') {
    fail:
B
bellard 已提交
3346
        *q = '\0';
3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381
        *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 已提交
3382
            qemu_printf("unterminated string\n");
3383 3384 3385 3386
            goto fail;
        }
        p++;
    } else {
3387
        while (*p != '\0' && !qemu_isspace(*p)) {
3388 3389 3390 3391 3392 3393
            if ((q - buf) < buf_size - 1) {
                *q++ = *p;
            }
            p++;
        }
    }
B
bellard 已提交
3394
    *q = '\0';
3395 3396 3397 3398
    *pp = p;
    return 0;
}

3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424
/*
 * 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;
}

3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451
/**
 * 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;
}

3452 3453 3454 3455 3456
static int default_fmt_format = 'x';
static int default_fmt_size = 4;

#define MAX_ARGS 16

3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468
static int is_valid_option(const char *c, const char *typestr)
{
    char option[3];
  
    option[0] = '-';
    option[1] = *c;
    option[2] = '\0';
  
    typestr = strstr(typestr, option);
    return (typestr != NULL);
}

3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481
static const mon_cmd_t *monitor_find_command(const char *cmdname)
{
    const mon_cmd_t *cmd;

    for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
        if (compare_cmd(cmdname, cmd->name)) {
            return cmd;
        }
    }

    return NULL;
}

A
Anthony Liguori 已提交
3482
static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3483 3484
                                              const char *cmdline,
                                              QDict *qdict)
3485
{
3486
    const char *p, *typestr;
3487
    int c;
A
Anthony Liguori 已提交
3488
    const mon_cmd_t *cmd;
3489 3490
    char cmdname[256];
    char buf[1024];
3491
    char *key;
B
bellard 已提交
3492 3493

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

3497
    /* extract the command name */
3498 3499
    p = get_command_name(cmdline, cmdname, sizeof(cmdname));
    if (!p)
3500
        return NULL;
3501

3502 3503
    cmd = monitor_find_command(cmdname);
    if (!cmd) {
L
Luiz Capitulino 已提交
3504
        monitor_printf(mon, "unknown command: '%s'\n", cmdname);
3505
        return NULL;
3506 3507 3508 3509
    }

    /* parse the parameters */
    typestr = cmd->args_type;
B
bellard 已提交
3510
    for(;;) {
3511 3512
        typestr = key_get_info(typestr, &key);
        if (!typestr)
B
bellard 已提交
3513
            break;
3514
        c = *typestr;
3515 3516 3517
        typestr++;
        switch(c) {
        case 'F':
B
bellard 已提交
3518
        case 'B':
3519 3520 3521
        case 's':
            {
                int ret;
3522

3523
                while (qemu_isspace(*p))
3524 3525 3526 3527 3528
                    p++;
                if (*typestr == '?') {
                    typestr++;
                    if (*p == '\0') {
                        /* no optional string: NULL argument */
3529
                        break;
3530 3531 3532 3533
                    }
                }
                ret = get_str(buf, sizeof(buf), &p);
                if (ret < 0) {
B
bellard 已提交
3534 3535
                    switch(c) {
                    case 'F':
A
aliguori 已提交
3536 3537
                        monitor_printf(mon, "%s: filename expected\n",
                                       cmdname);
B
bellard 已提交
3538 3539
                        break;
                    case 'B':
A
aliguori 已提交
3540 3541
                        monitor_printf(mon, "%s: block device name expected\n",
                                       cmdname);
B
bellard 已提交
3542 3543
                        break;
                    default:
A
aliguori 已提交
3544
                        monitor_printf(mon, "%s: string expected\n", cmdname);
B
bellard 已提交
3545 3546
                        break;
                    }
3547 3548
                    goto fail;
                }
3549
                qdict_put(qdict, key, qstring_from_str(buf));
3550
            }
B
bellard 已提交
3551
            break;
3552 3553 3554
        case '/':
            {
                int count, format, size;
3555

3556
                while (qemu_isspace(*p))
3557 3558 3559 3560 3561
                    p++;
                if (*p == '/') {
                    /* format found */
                    p++;
                    count = 1;
3562
                    if (qemu_isdigit(*p)) {
3563
                        count = 0;
3564
                        while (qemu_isdigit(*p)) {
3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602
                            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:
3603
                    if (*p != '\0' && !qemu_isspace(*p)) {
A
aliguori 已提交
3604 3605
                        monitor_printf(mon, "invalid char in format: '%c'\n",
                                       *p);
3606 3607 3608 3609
                        goto fail;
                    }
                    if (format < 0)
                        format = default_fmt_format;
3610 3611 3612 3613
                    if (format != 'i') {
                        /* for 'i', not specifying a size gives -1 as size */
                        if (size < 0)
                            size = default_fmt_size;
A
aurel32 已提交
3614
                        default_fmt_size = size;
3615
                    }
3616 3617 3618 3619
                    default_fmt_format = format;
                } else {
                    count = 1;
                    format = default_fmt_format;
3620 3621 3622 3623 3624
                    if (format != 'i') {
                        size = default_fmt_size;
                    } else {
                        size = -1;
                    }
3625
                }
3626 3627 3628
                qdict_put(qdict, "count", qint_from_int(count));
                qdict_put(qdict, "format", qint_from_int(format));
                qdict_put(qdict, "size", qint_from_int(size));
3629
            }
B
bellard 已提交
3630
            break;
3631
        case 'i':
B
bellard 已提交
3632
        case 'l':
3633
        case 'M':
3634
            {
B
blueswir1 已提交
3635
                int64_t val;
3636

3637
                while (qemu_isspace(*p))
3638
                    p++;
B
bellard 已提交
3639 3640
                if (*typestr == '?' || *typestr == '.') {
                    if (*typestr == '?') {
3641 3642 3643 3644
                        if (*p == '\0') {
                            typestr++;
                            break;
                        }
B
bellard 已提交
3645 3646 3647
                    } else {
                        if (*p == '.') {
                            p++;
3648
                            while (qemu_isspace(*p))
B
bellard 已提交
3649 3650
                                p++;
                        } else {
3651 3652
                            typestr++;
                            break;
B
bellard 已提交
3653 3654
                        }
                    }
B
bellard 已提交
3655
                    typestr++;
3656
                }
A
aliguori 已提交
3657
                if (get_expr(mon, &val, &p))
3658
                    goto fail;
3659 3660 3661 3662 3663
                /* 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;
3664 3665
                } else if (c == 'M') {
                    val <<= 20;
3666
                }
3667
                qdict_put(qdict, key, qint_from_int(val));
3668 3669
            }
            break;
3670
        case 'b':
3671
        case 'T':
3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685
            {
                double val;

                while (qemu_isspace(*p))
                    p++;
                if (*typestr == '?') {
                    typestr++;
                    if (*p == '\0') {
                        break;
                    }
                }
                if (get_double(mon, &val, &p) < 0) {
                    goto fail;
                }
3686
                if (c == 'b' && *p) {
3687 3688 3689 3690 3691 3692 3693 3694 3695
                    switch (*p) {
                    case 'K': case 'k':
                        val *= 1 << 10; p++; break;
                    case 'M': case 'm':
                        val *= 1 << 20; p++; break;
                    case 'G': case 'g':
                        val *= 1 << 30; p++; break;
                    }
                }
3696 3697 3698 3699 3700 3701 3702 3703 3704 3705
                if (c == 'T' && p[0] && p[1] == 's') {
                    switch (*p) {
                    case 'm':
                        val /= 1e3; p += 2; break;
                    case 'u':
                        val /= 1e6; p += 2; break;
                    case 'n':
                        val /= 1e9; p += 2; break;
                    }
                }
3706 3707 3708 3709 3710 3711 3712
                if (*p && !qemu_isspace(*p)) {
                    monitor_printf(mon, "Unknown unit suffix\n");
                    goto fail;
                }
                qdict_put(qdict, key, qfloat_from_double(val));
            }
            break;
3713 3714
        case '-':
            {
3715 3716
                const char *tmp = p;
                int has_option, skip_key = 0;
3717
                /* option */
3718

3719 3720 3721
                c = *typestr++;
                if (c == '\0')
                    goto bad_type;
3722
                while (qemu_isspace(*p))
3723 3724 3725 3726
                    p++;
                has_option = 0;
                if (*p == '-') {
                    p++;
3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741
                    if(c != *p) {
                        if(!is_valid_option(p, typestr)) {
                  
                            monitor_printf(mon, "%s: unsupported option -%c\n",
                                           cmdname, *p);
                            goto fail;
                        } else {
                            skip_key = 1;
                        }
                    }
                    if(skip_key) {
                        p = tmp;
                    } else {
                        p++;
                        has_option = 1;
3742 3743
                    }
                }
3744
                qdict_put(qdict, key, qint_from_int(has_option));
3745 3746 3747 3748
            }
            break;
        default:
        bad_type:
A
aliguori 已提交
3749
            monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
3750 3751
            goto fail;
        }
3752 3753
        qemu_free(key);
        key = NULL;
B
bellard 已提交
3754
    }
3755
    /* check that all arguments were parsed */
3756
    while (qemu_isspace(*p))
3757 3758
        p++;
    if (*p != '\0') {
A
aliguori 已提交
3759 3760
        monitor_printf(mon, "%s: extraneous characters at the end of line\n",
                       cmdname);
3761
        goto fail;
B
bellard 已提交
3762
    }
3763

3764
    return cmd;
G
Gerd Hoffmann 已提交
3765

3766
fail:
3767
    qemu_free(key);
3768 3769 3770
    return NULL;
}

L
Luiz Capitulino 已提交
3771 3772 3773 3774 3775 3776 3777
static void monitor_print_error(Monitor *mon)
{
    qerror_print(mon->error);
    QDECREF(mon->error);
    mon->error = NULL;
}

3778 3779
static int is_async_return(const QObject *data)
{
3780 3781 3782 3783 3784
    if (data && qobject_type(data) == QTYPE_QDICT) {
        return qdict_haskey(qobject_to_qdict(data), "__mon_async");
    }

    return 0;
3785 3786
}

3787 3788 3789 3790 3791 3792
static void monitor_call_handler(Monitor *mon, const mon_cmd_t *cmd,
                                 const QDict *params)
{
    QObject *data = NULL;

    cmd->mhandler.cmd_new(mon, params, &data);
L
Luiz Capitulino 已提交
3793

3794 3795 3796 3797 3798 3799 3800 3801 3802
    if (is_async_return(data)) {
        /*
         * Asynchronous commands have no initial return data but they can
         * generate errors.  Data is returned via the async completion handler.
         */
        if (monitor_ctrl_mode(mon) && monitor_has_error(mon)) {
            monitor_protocol_emitter(mon, NULL);
        }
    } else if (monitor_ctrl_mode(mon)) {
L
Luiz Capitulino 已提交
3803 3804 3805 3806 3807 3808 3809
        /* Monitor Protocol */
        monitor_protocol_emitter(mon, data);
    } else {
        /* User Protocol */
         if (data)
            cmd->user_print(mon, data);
    }
3810 3811 3812 3813

    qobject_decref(data);
}

3814
static void handle_user_command(Monitor *mon, const char *cmdline)
3815 3816
{
    QDict *qdict;
A
Anthony Liguori 已提交
3817
    const mon_cmd_t *cmd;
3818 3819 3820

    qdict = qdict_new();

L
Luiz Capitulino 已提交
3821
    cmd = monitor_parse_command(mon, cmdline, qdict);
3822 3823 3824 3825 3826
    if (!cmd)
        goto out;

    qemu_errors_to_mon(mon);

3827 3828 3829
    if (monitor_handler_is_async(cmd)) {
        user_async_cmd_handler(mon, cmd, qdict);
    } else if (monitor_handler_ported(cmd)) {
3830
        monitor_call_handler(mon, cmd, qdict);
3831
    } else {
3832
        cmd->mhandler.cmd(mon, qdict);
3833 3834
    }

L
Luiz Capitulino 已提交
3835 3836 3837 3838
    if (monitor_has_error(mon))
        monitor_print_error(mon);

    qemu_errors_to_previous();
3839 3840

out:
3841
    QDECREF(qdict);
B
bellard 已提交
3842 3843
}

B
bellard 已提交
3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861
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))) {
3862
            readline_add_completion(cur_mon->rs, cmd);
B
bellard 已提交
3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878
        }
        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;

3879
    p = strrchr(input, '/');
B
bellard 已提交
3880 3881 3882
    if (!p) {
        input_path_len = 0;
        pstrcpy(file_prefix, sizeof(file_prefix), input);
B
blueswir1 已提交
3883
        pstrcpy(path, sizeof(path), ".");
B
bellard 已提交
3884 3885 3886 3887 3888 3889 3890 3891 3892
    } 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 已提交
3893 3894
    monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
                   input, path, file_prefix);
B
bellard 已提交
3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905
#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 已提交
3906 3907 3908
            if (input_path_len < sizeof(file))
                pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
                        d->d_name);
B
bellard 已提交
3909 3910 3911 3912 3913
            /* 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 已提交
3914
                pstrcat(file, sizeof(file), "/");
3915
            readline_add_completion(cur_mon->rs, file);
B
bellard 已提交
3916 3917 3918 3919 3920
        }
    }
    closedir(ffs);
}

3921
static void block_completion_it(void *opaque, BlockDriverState *bs)
B
bellard 已提交
3922
{
3923
    const char *name = bdrv_get_device_name(bs);
B
bellard 已提交
3924 3925 3926 3927
    const char *input = opaque;

    if (input[0] == '\0' ||
        !strncmp(name, (char *)input, strlen(input))) {
3928
        readline_add_completion(cur_mon->rs, name);
B
bellard 已提交
3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942
    }
}

/* 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(;;) {
3943
        while (qemu_isspace(*p))
B
bellard 已提交
3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957
            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;
}

3958 3959 3960 3961 3962 3963
static const char *next_arg_type(const char *typestr)
{
    const char *p = strchr(typestr, ':');
    return (p != NULL ? ++p : typestr);
}

3964
static void monitor_find_completion(const char *cmdline)
B
bellard 已提交
3965 3966 3967 3968 3969
{
    const char *cmdname;
    char *args[MAX_ARGS];
    int nb_args, i, len;
    const char *ptype, *str;
A
Anthony Liguori 已提交
3970
    const mon_cmd_t *cmd;
3971
    const KeyDef *key;
B
bellard 已提交
3972 3973 3974 3975

    parse_cmdline(cmdline, &nb_args, args);
#ifdef DEBUG_COMPLETION
    for(i = 0; i < nb_args; i++) {
A
aliguori 已提交
3976
        monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
B
bellard 已提交
3977 3978 3979 3980 3981 3982
    }
#endif

    /* if the line ends with a space, it means we want to complete the
       next arg */
    len = strlen(cmdline);
3983
    if (len > 0 && qemu_isspace(cmdline[len - 1])) {
B
bellard 已提交
3984 3985 3986 3987 3988 3989 3990 3991 3992 3993
        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];
3994
        readline_set_completion_index(cur_mon->rs, strlen(cmdname));
A
aliguori 已提交
3995
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
B
bellard 已提交
3996 3997 3998 3999
            cmd_completion(cmdname, cmd->name);
        }
    } else {
        /* find the command */
A
aliguori 已提交
4000
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
B
bellard 已提交
4001 4002 4003 4004 4005
            if (compare_cmd(args[0], cmd->name))
                goto found;
        }
        return;
    found:
4006
        ptype = next_arg_type(cmd->args_type);
B
bellard 已提交
4007 4008
        for(i = 0; i < nb_args - 2; i++) {
            if (*ptype != '\0') {
4009
                ptype = next_arg_type(ptype);
B
bellard 已提交
4010
                while (*ptype == '?')
4011
                    ptype = next_arg_type(ptype);
B
bellard 已提交
4012 4013 4014
            }
        }
        str = args[nb_args - 1];
4015 4016 4017
        if (*ptype == '-' && ptype[1] != '\0') {
            ptype += 2;
        }
B
bellard 已提交
4018 4019 4020
        switch(*ptype) {
        case 'F':
            /* file completion */
4021
            readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
4022 4023 4024 4025
            file_completion(str);
            break;
        case 'B':
            /* block device name completion */
4026
            readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
4027 4028
            bdrv_iterate(block_completion_it, (void *)str);
            break;
B
bellard 已提交
4029 4030 4031
        case 's':
            /* XXX: more generic ? */
            if (!strcmp(cmd->name, "info")) {
4032
                readline_set_completion_index(cur_mon->rs, strlen(str));
B
bellard 已提交
4033 4034 4035
                for(cmd = info_cmds; cmd->name != NULL; cmd++) {
                    cmd_completion(str, cmd->name);
                }
4036
            } else if (!strcmp(cmd->name, "sendkey")) {
B
blueswir1 已提交
4037 4038 4039
                char *sep = strrchr(str, '-');
                if (sep)
                    str = sep + 1;
4040
                readline_set_completion_index(cur_mon->rs, strlen(str));
4041 4042 4043
                for(key = key_defs; key->name != NULL; key++) {
                    cmd_completion(str, key->name);
                }
4044 4045 4046 4047 4048
            } 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 已提交
4049 4050
            }
            break;
B
bellard 已提交
4051 4052 4053 4054 4055 4056 4057 4058
        default:
            break;
        }
    }
    for(i = 0; i < nb_args; i++)
        qemu_free(args[i]);
}

4059
static int monitor_can_read(void *opaque)
B
bellard 已提交
4060
{
4061 4062
    Monitor *mon = opaque;

J
Jan Kiszka 已提交
4063
    return (mon->suspend_cnt == 0) ? 1 : 0;
B
bellard 已提交
4064 4065
}

L
Luiz Capitulino 已提交
4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131
typedef struct CmdArgs {
    QString *name;
    int type;
    int flag;
    int optional;
} CmdArgs;

static int check_opt(const CmdArgs *cmd_args, const char *name, QDict *args)
{
    if (!cmd_args->optional) {
        qemu_error_new(QERR_MISSING_PARAMETER, name);
        return -1;
    }

    if (cmd_args->type == '-') {
        /* handlers expect a value, they need to be changed */
        qdict_put(args, name, qint_from_int(0));
    }

    return 0;
}

static int check_arg(const CmdArgs *cmd_args, QDict *args)
{
    QObject *value;
    const char *name;

    name = qstring_get_str(cmd_args->name);

    if (!args) {
        return check_opt(cmd_args, name, args);
    }

    value = qdict_get(args, name);
    if (!value) {
        return check_opt(cmd_args, name, args);
    }

    switch (cmd_args->type) {
        case 'F':
        case 'B':
        case 's':
            if (qobject_type(value) != QTYPE_QSTRING) {
                qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "string");
                return -1;
            }
            break;
        case '/': {
            int i;
            const char *keys[] = { "count", "format", "size", NULL };

            for (i = 0; keys[i]; i++) {
                QObject *obj = qdict_get(args, keys[i]);
                if (!obj) {
                    qemu_error_new(QERR_MISSING_PARAMETER, name);
                    return -1;
                }
                if (qobject_type(obj) != QTYPE_QINT) {
                    qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "int");
                    return -1;
                }
            }
            break;
        }
        case 'i':
        case 'l':
4132
        case 'M':
L
Luiz Capitulino 已提交
4133 4134 4135 4136 4137
            if (qobject_type(value) != QTYPE_QINT) {
                qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "int");
                return -1;
            }
            break;
4138
        case 'b':
4139
        case 'T':
4140 4141 4142 4143 4144
            if (qobject_type(value) != QTYPE_QINT && qobject_type(value) != QTYPE_QFLOAT) {
                qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "number");
                return -1;
            }
            break;
L
Luiz Capitulino 已提交
4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183
        case '-':
            if (qobject_type(value) != QTYPE_QINT &&
                qobject_type(value) != QTYPE_QBOOL) {
                qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "bool");
                return -1;
            }
            if (qobject_type(value) == QTYPE_QBOOL) {
                /* handlers expect a QInt, they need to be changed */
                qdict_put(args, name,
                         qint_from_int(qbool_get_int(qobject_to_qbool(value))));
            }
            break;
        default:
            /* impossible */
            abort();
    }

    return 0;
}

static void cmd_args_init(CmdArgs *cmd_args)
{
    cmd_args->name = qstring_new();
    cmd_args->type = cmd_args->flag = cmd_args->optional = 0;
}

/*
 * This is not trivial, we have to parse Monitor command's argument
 * type syntax to be able to check the arguments provided by clients.
 *
 * In the near future we will be using an array for that and will be
 * able to drop all this parsing...
 */
static int monitor_check_qmp_args(const mon_cmd_t *cmd, QDict *args)
{
    int err;
    const char *p;
    CmdArgs cmd_args;

4184
    if (cmd->args_type == NULL) {
L
Luiz Capitulino 已提交
4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231
        return (qdict_size(args) == 0 ? 0 : -1);
    }

    err = 0;
    cmd_args_init(&cmd_args);

    for (p = cmd->args_type;; p++) {
        if (*p == ':') {
            cmd_args.type = *++p;
            p++;
            if (cmd_args.type == '-') {
                cmd_args.flag = *p++;
                cmd_args.optional = 1;
            } else if (*p == '?') {
                cmd_args.optional = 1;
                p++;
            }

            assert(*p == ',' || *p == '\0');
            err = check_arg(&cmd_args, args);

            QDECREF(cmd_args.name);
            cmd_args_init(&cmd_args);

            if (err < 0) {
                break;
            }
        } else {
            qstring_append_chr(cmd_args.name, *p);
        }

        if (*p == '\0') {
            break;
        }
    }

    QDECREF(cmd_args.name);
    return err;
}

static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
{
    int err;
    QObject *obj;
    QDict *input, *args;
    const mon_cmd_t *cmd;
    Monitor *mon = cur_mon;
L
Luiz Capitulino 已提交
4232
    const char *cmd_name, *info_item;
L
Luiz Capitulino 已提交
4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262

    args = NULL;
    qemu_errors_to_mon(mon);

    obj = json_parser_parse(tokens, NULL);
    if (!obj) {
        // FIXME: should be triggered in json_parser_parse()
        qemu_error_new(QERR_JSON_PARSING);
        goto err_out;
    } else if (qobject_type(obj) != QTYPE_QDICT) {
        qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "object");
        qobject_decref(obj);
        goto err_out;
    }

    input = qobject_to_qdict(obj);

    mon->mc->id = qdict_get(input, "id");
    qobject_incref(mon->mc->id);

    obj = qdict_get(input, "execute");
    if (!obj) {
        qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "execute");
        goto err_input;
    } else if (qobject_type(obj) != QTYPE_QSTRING) {
        qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "string");
        goto err_input;
    }

    cmd_name = qstring_get_str(qobject_to_qstring(obj));
L
Luiz Capitulino 已提交
4263 4264 4265 4266 4267 4268

    /*
     * XXX: We need this special case until we get info handlers
     * converted into 'query-' commands
     */
    if (compare_cmd(cmd_name, "info")) {
L
Luiz Capitulino 已提交
4269 4270
        qemu_error_new(QERR_COMMAND_NOT_FOUND, cmd_name);
        goto err_input;
L
Luiz Capitulino 已提交
4271 4272 4273 4274 4275 4276
    } else if (strstart(cmd_name, "query-", &info_item)) {
        cmd = monitor_find_command("info");
        qdict_put_obj(input, "arguments",
                      qobject_from_jsonf("{ 'item': %s }", info_item));
    } else {
        cmd = monitor_find_command(cmd_name);
4277
        if (!cmd || !monitor_handler_ported(cmd)) {
L
Luiz Capitulino 已提交
4278 4279 4280
            qemu_error_new(QERR_COMMAND_NOT_FOUND, cmd_name);
            goto err_input;
        }
L
Luiz Capitulino 已提交
4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297
    }

    obj = qdict_get(input, "arguments");
    if (!obj) {
        args = qdict_new();
    } else {
        args = qobject_to_qdict(obj);
        QINCREF(args);
    }

    QDECREF(input);

    err = monitor_check_qmp_args(cmd, args);
    if (err < 0) {
        goto err_out;
    }

4298 4299 4300 4301 4302
    if (monitor_handler_is_async(cmd)) {
        qmp_async_cmd_handler(mon, cmd, args);
    } else {
        monitor_call_handler(mon, cmd, args);
    }
L
Luiz Capitulino 已提交
4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313
    goto out;

err_input:
    QDECREF(input);
err_out:
    monitor_protocol_emitter(mon, NULL);
out:
    QDECREF(args);
    qemu_errors_to_previous();
}

L
Luiz Capitulino 已提交
4314 4315 4316 4317 4318 4319 4320 4321 4322
/**
 * monitor_control_read(): Read and handle QMP input
 */
static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
{
    Monitor *old_mon = cur_mon;

    cur_mon = opaque;

L
Luiz Capitulino 已提交
4323
    json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
L
Luiz Capitulino 已提交
4324 4325 4326 4327

    cur_mon = old_mon;
}

4328
static void monitor_read(void *opaque, const uint8_t *buf, int size)
B
bellard 已提交
4329
{
4330
    Monitor *old_mon = cur_mon;
4331
    int i;
A
aliguori 已提交
4332

4333 4334
    cur_mon = opaque;

4335 4336 4337 4338 4339 4340 4341
    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
4342
            handle_user_command(cur_mon, (char *)buf);
4343
    }
B
bellard 已提交
4344

4345 4346
    cur_mon = old_mon;
}
4347

A
aliguori 已提交
4348
static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
B
bellard 已提交
4349
{
4350
    monitor_suspend(mon);
4351
    handle_user_command(mon, cmdline);
4352
    monitor_resume(mon);
4353 4354
}

4355
int monitor_suspend(Monitor *mon)
4356
{
4357 4358
    if (!mon->rs)
        return -ENOTTY;
4359
    mon->suspend_cnt++;
4360
    return 0;
4361 4362
}

A
aliguori 已提交
4363
void monitor_resume(Monitor *mon)
4364
{
4365 4366
    if (!mon->rs)
        return;
4367 4368
    if (--mon->suspend_cnt == 0)
        readline_show_prompt(mon->rs);
B
bellard 已提交
4369 4370
}

L
Luiz Capitulino 已提交
4371 4372 4373 4374 4375 4376 4377 4378 4379
/**
 * monitor_control_event(): Print QMP gretting
 */
static void monitor_control_event(void *opaque, int event)
{
    if (event == CHR_EVENT_OPENED) {
        QObject *data;
        Monitor *mon = opaque;

L
Luiz Capitulino 已提交
4380 4381
        json_message_parser_init(&mon->mc->parser, handle_qmp_command);

L
Luiz Capitulino 已提交
4382 4383 4384 4385 4386 4387 4388 4389
        data = qobject_from_jsonf("{ 'QMP': { 'capabilities': [] } }");
        assert(data != NULL);

        monitor_json_emitter(mon, data);
        qobject_decref(data);
    }
}

4390
static void monitor_event(void *opaque, int event)
4391
{
A
aliguori 已提交
4392 4393
    Monitor *mon = opaque;

4394 4395
    switch (event) {
    case CHR_EVENT_MUX_IN:
G
Gerd Hoffmann 已提交
4396 4397 4398 4399 4400 4401 4402 4403
        mon->mux_out = 0;
        if (mon->reset_seen) {
            readline_restart(mon->rs);
            monitor_resume(mon);
            monitor_flush(mon);
        } else {
            mon->suspend_cnt = 0;
        }
4404 4405 4406
        break;

    case CHR_EVENT_MUX_OUT:
G
Gerd Hoffmann 已提交
4407 4408 4409 4410 4411 4412 4413 4414 4415 4416
        if (mon->reset_seen) {
            if (mon->suspend_cnt == 0) {
                monitor_printf(mon, "\n");
            }
            monitor_flush(mon);
            monitor_suspend(mon);
        } else {
            mon->suspend_cnt++;
        }
        mon->mux_out = 1;
4417
        break;
4418

4419
    case CHR_EVENT_OPENED:
4420 4421
        monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
                       "information\n", QEMU_VERSION);
G
Gerd Hoffmann 已提交
4422
        if (!mon->mux_out) {
4423
            readline_show_prompt(mon->rs);
G
Gerd Hoffmann 已提交
4424 4425
        }
        mon->reset_seen = 1;
4426 4427
        break;
    }
4428 4429
}

4430 4431 4432 4433 4434 4435 4436 4437 4438

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

4439
void monitor_init(CharDriverState *chr, int flags)
B
bellard 已提交
4440
{
4441
    static int is_first_init = 1;
4442
    Monitor *mon;
T
ths 已提交
4443 4444

    if (is_first_init) {
4445
        key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
T
ths 已提交
4446 4447
        is_first_init = 0;
    }
4448 4449

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

4451
    mon->chr = chr;
4452
    mon->flags = flags;
4453 4454 4455 4456
    if (flags & MONITOR_USE_READLINE) {
        mon->rs = readline_init(mon, monitor_find_completion);
        monitor_read_command(mon, 0);
    }
4457

L
Luiz Capitulino 已提交
4458
    if (monitor_ctrl_mode(mon)) {
L
Luiz Capitulino 已提交
4459
        mon->mc = qemu_mallocz(sizeof(MonitorControl));
L
Luiz Capitulino 已提交
4460 4461 4462 4463 4464 4465 4466
        /* Control mode requires special handlers */
        qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
                              monitor_control_event, mon);
    } else {
        qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
                              monitor_event, mon);
    }
4467

B
Blue Swirl 已提交
4468
    QLIST_INSERT_HEAD(&mon_list, mon, entry);
4469
    if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
4470
        cur_mon = mon;
B
bellard 已提交
4471 4472
}

A
aliguori 已提交
4473
static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
B
bellard 已提交
4474
{
4475 4476
    BlockDriverState *bs = opaque;
    int ret = 0;
B
bellard 已提交
4477

4478
    if (bdrv_set_key(bs, password) != 0) {
A
aliguori 已提交
4479
        monitor_printf(mon, "invalid password\n");
4480
        ret = -EPERM;
B
bellard 已提交
4481
    }
4482 4483
    if (mon->password_completion_cb)
        mon->password_completion_cb(mon->password_opaque, ret);
4484

4485
    monitor_read_command(mon, 1);
B
bellard 已提交
4486
}
4487

A
aliguori 已提交
4488
void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4489 4490
                                 BlockDriverCompletionFunc *completion_cb,
                                 void *opaque)
4491
{
4492 4493
    int err;

4494 4495 4496 4497 4498
    if (!bdrv_key_required(bs)) {
        if (completion_cb)
            completion_cb(opaque, 0);
        return;
    }
4499

4500 4501 4502 4503 4504
    if (monitor_ctrl_mode(mon)) {
        qemu_error_new(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
        return;
    }

A
aliguori 已提交
4505 4506
    monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
                   bdrv_get_encrypted_filename(bs));
4507

4508 4509
    mon->password_completion_cb = completion_cb;
    mon->password_opaque = opaque;
4510

4511 4512 4513 4514
    err = monitor_read_password(mon, bdrv_password_cb, bs);

    if (err && completion_cb)
        completion_cb(opaque, err);
4515
}
G
Gerd Hoffmann 已提交
4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529

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

B
Blue Swirl 已提交
4530
static QemuErrorSink *qemu_error_sink;
G
Gerd Hoffmann 已提交
4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581

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;
    }
}
L
Luiz Capitulino 已提交
4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605

void qemu_error_internal(const char *file, int linenr, const char *func,
                         const char *fmt, ...)
{
    va_list va;
    QError *qerror;

    assert(qemu_error_sink != NULL);

    va_start(va, fmt);
    qerror = qerror_from_info(file, linenr, func, fmt, &va);
    va_end(va);

    switch (qemu_error_sink->dest) {
    case ERR_SINK_FILE:
        qerror_print(qerror);
        QDECREF(qerror);
        break;
    case ERR_SINK_MONITOR:
        assert(qemu_error_sink->mon->error == NULL);
        qemu_error_sink->mon->error = qerror;
        break;
    }
}