Statistics
| Branch: | Revision:

root / monitor.c @ 28c28973

History | View | Annotate | Download (122.4 kB)

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

    
59
//#define DEBUG
60
//#define DEBUG_COMPLETION
61

    
62
/*
63
 * Supported types:
64
 *
65
 * 'F'          filename
66
 * 'B'          block device name
67
 * 's'          string (accept optional quote)
68
 * 'O'          option string of the form NAME=VALUE,...
69
 *              parsed according to QemuOptsList given by its name
70
 *              Example: 'device:O' uses qemu_device_opts.
71
 *              Restriction: only lists with empty desc are supported
72
 *              TODO lift the restriction
73
 * 'i'          32 bit integer
74
 * 'l'          target long (32 or 64 bit)
75
 * 'M'          just like 'l', except in user mode the value is
76
 *              multiplied by 2^20 (think Mebibyte)
77
 * 'b'          double
78
 *              user mode accepts an optional G, g, M, m, K, k suffix,
79
 *              which multiplies the value by 2^30 for suffixes G and
80
 *              g, 2^20 for M and m, 2^10 for K and k
81
 * 'T'          double
82
 *              user mode accepts an optional ms, us, ns suffix,
83
 *              which divides the value by 1e3, 1e6, 1e9, respectively
84
 * '/'          optional gdb-like print format (like "/10x")
85
 *
86
 * '?'          optional type (for all types, except '/')
87
 * '.'          other form of optional type (for 'i' and 'l')
88
 * '-'          optional parameter (eg. '-f')
89
 *
90
 */
91

    
92
typedef struct MonitorCompletionData MonitorCompletionData;
93
struct MonitorCompletionData {
94
    Monitor *mon;
95
    void (*user_print)(Monitor *mon, const QObject *data);
96
};
97

    
98
typedef struct mon_cmd_t {
99
    const char *name;
100
    const char *args_type;
101
    const char *params;
102
    const char *help;
103
    void (*user_print)(Monitor *mon, const QObject *data);
104
    union {
105
        void (*info)(Monitor *mon);
106
        void (*info_new)(Monitor *mon, QObject **ret_data);
107
        int  (*info_async)(Monitor *mon, MonitorCompletion *cb, void *opaque);
108
        void (*cmd)(Monitor *mon, const QDict *qdict);
109
        int  (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
110
        int  (*cmd_async)(Monitor *mon, const QDict *params,
111
                          MonitorCompletion *cb, void *opaque);
112
    } mhandler;
113
    int async;
114
} mon_cmd_t;
115

    
116
/* file descriptors passed via SCM_RIGHTS */
117
typedef struct mon_fd_t mon_fd_t;
118
struct mon_fd_t {
119
    char *name;
120
    int fd;
121
    QLIST_ENTRY(mon_fd_t) next;
122
};
123

    
124
typedef struct MonitorControl {
125
    QObject *id;
126
    JSONMessageParser parser;
127
    int command_mode;
128
} MonitorControl;
129

    
130
struct Monitor {
131
    CharDriverState *chr;
132
    int mux_out;
133
    int reset_seen;
134
    int flags;
135
    int suspend_cnt;
136
    uint8_t outbuf[1024];
137
    int outbuf_index;
138
    ReadLineState *rs;
139
    MonitorControl *mc;
140
    CPUState *mon_cpu;
141
    BlockDriverCompletionFunc *password_completion_cb;
142
    void *password_opaque;
143
#ifdef CONFIG_DEBUG_MONITOR
144
    int print_calls_nr;
145
#endif
146
    QError *error;
147
    QLIST_HEAD(,mon_fd_t) fds;
148
    QLIST_ENTRY(Monitor) entry;
149
};
150

    
151
#ifdef CONFIG_DEBUG_MONITOR
152
#define MON_DEBUG(fmt, ...) do {    \
153
    fprintf(stderr, "Monitor: ");       \
154
    fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
155

    
156
static inline void mon_print_count_inc(Monitor *mon)
157
{
158
    mon->print_calls_nr++;
159
}
160

    
161
static inline void mon_print_count_init(Monitor *mon)
162
{
163
    mon->print_calls_nr = 0;
164
}
165

    
166
static inline int mon_print_count_get(const Monitor *mon)
167
{
168
    return mon->print_calls_nr;
169
}
170

    
171
#else /* !CONFIG_DEBUG_MONITOR */
172
#define MON_DEBUG(fmt, ...) do { } while (0)
173
static inline void mon_print_count_inc(Monitor *mon) { }
174
static inline void mon_print_count_init(Monitor *mon) { }
175
static inline int mon_print_count_get(const Monitor *mon) { return 0; }
176
#endif /* CONFIG_DEBUG_MONITOR */
177

    
178
static QLIST_HEAD(mon_list, Monitor) mon_list;
179

    
180
static const mon_cmd_t mon_cmds[];
181
static const mon_cmd_t info_cmds[];
182

    
183
Monitor *cur_mon;
184
Monitor *default_mon;
185

    
186
static void monitor_command_cb(Monitor *mon, const char *cmdline,
187
                               void *opaque);
188

    
189
static inline int qmp_cmd_mode(const Monitor *mon)
190
{
191
    return (mon->mc ? mon->mc->command_mode : 0);
192
}
193

    
194
/* Return true if in control mode, false otherwise */
195
static inline int monitor_ctrl_mode(const Monitor *mon)
196
{
197
    return (mon->flags & MONITOR_USE_CONTROL);
198
}
199

    
200
/* Return non-zero iff we have a current monitor, and it is in QMP mode.  */
201
int monitor_cur_is_qmp(void)
202
{
203
    return cur_mon && monitor_ctrl_mode(cur_mon);
204
}
205

    
206
static void monitor_read_command(Monitor *mon, int show_prompt)
207
{
208
    if (!mon->rs)
209
        return;
210

    
211
    readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
212
    if (show_prompt)
213
        readline_show_prompt(mon->rs);
214
}
215

    
216
static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
217
                                 void *opaque)
218
{
219
    if (monitor_ctrl_mode(mon)) {
220
        qerror_report(QERR_MISSING_PARAMETER, "password");
221
        return -EINVAL;
222
    } else if (mon->rs) {
223
        readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
224
        /* prompt is printed on return from the command handler */
225
        return 0;
226
    } else {
227
        monitor_printf(mon, "terminal does not support password prompting\n");
228
        return -ENOTTY;
229
    }
230
}
231

    
232
void monitor_flush(Monitor *mon)
233
{
234
    if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
235
        qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
236
        mon->outbuf_index = 0;
237
    }
238
}
239

    
240
/* flush at every end of line or if the buffer is full */
241
static void monitor_puts(Monitor *mon, const char *str)
242
{
243
    char c;
244

    
245
    for(;;) {
246
        c = *str++;
247
        if (c == '\0')
248
            break;
249
        if (c == '\n')
250
            mon->outbuf[mon->outbuf_index++] = '\r';
251
        mon->outbuf[mon->outbuf_index++] = c;
252
        if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
253
            || c == '\n')
254
            monitor_flush(mon);
255
    }
256
}
257

    
258
void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
259
{
260
    char buf[4096];
261

    
262
    if (!mon)
263
        return;
264

    
265
    mon_print_count_inc(mon);
266

    
267
    if (monitor_ctrl_mode(mon)) {
268
        return;
269
    }
270

    
271
    vsnprintf(buf, sizeof(buf), fmt, ap);
272
    monitor_puts(mon, buf);
273
}
274

    
275
void monitor_printf(Monitor *mon, const char *fmt, ...)
276
{
277
    va_list ap;
278
    va_start(ap, fmt);
279
    monitor_vprintf(mon, fmt, ap);
280
    va_end(ap);
281
}
282

    
283
void monitor_print_filename(Monitor *mon, const char *filename)
284
{
285
    int i;
286

    
287
    for (i = 0; filename[i]; i++) {
288
        switch (filename[i]) {
289
        case ' ':
290
        case '"':
291
        case '\\':
292
            monitor_printf(mon, "\\%c", filename[i]);
293
            break;
294
        case '\t':
295
            monitor_printf(mon, "\\t");
296
            break;
297
        case '\r':
298
            monitor_printf(mon, "\\r");
299
            break;
300
        case '\n':
301
            monitor_printf(mon, "\\n");
302
            break;
303
        default:
304
            monitor_printf(mon, "%c", filename[i]);
305
            break;
306
        }
307
    }
308
}
309

    
310
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
311
{
312
    va_list ap;
313
    va_start(ap, fmt);
314
    monitor_vprintf((Monitor *)stream, fmt, ap);
315
    va_end(ap);
316
    return 0;
317
}
318

    
319
static void monitor_user_noop(Monitor *mon, const QObject *data) { }
320

    
321
static inline int monitor_handler_ported(const mon_cmd_t *cmd)
322
{
323
    return cmd->user_print != NULL;
324
}
325

    
326
static inline bool monitor_handler_is_async(const mon_cmd_t *cmd)
327
{
328
    return cmd->async != 0;
329
}
330

    
331
static inline int monitor_has_error(const Monitor *mon)
332
{
333
    return mon->error != NULL;
334
}
335

    
336
static void monitor_json_emitter(Monitor *mon, const QObject *data)
337
{
338
    QString *json;
339

    
340
    json = qobject_to_json(data);
341
    assert(json != NULL);
342

    
343
    qstring_append_chr(json, '\n');
344
    monitor_puts(mon, qstring_get_str(json));
345

    
346
    QDECREF(json);
347
}
348

    
349
static void monitor_protocol_emitter(Monitor *mon, QObject *data)
350
{
351
    QDict *qmp;
352

    
353
    qmp = qdict_new();
354

    
355
    if (!monitor_has_error(mon)) {
356
        /* success response */
357
        if (data) {
358
            qobject_incref(data);
359
            qdict_put_obj(qmp, "return", data);
360
        } else {
361
            /* return an empty QDict by default */
362
            qdict_put(qmp, "return", qdict_new());
363
        }
364
    } else {
365
        /* error response */
366
        qdict_put(mon->error->error, "desc", qerror_human(mon->error));
367
        qdict_put(qmp, "error", mon->error->error);
368
        QINCREF(mon->error->error);
369
        QDECREF(mon->error);
370
        mon->error = NULL;
371
    }
372

    
373
    if (mon->mc->id) {
374
        qdict_put_obj(qmp, "id", mon->mc->id);
375
        mon->mc->id = NULL;
376
    }
377

    
378
    monitor_json_emitter(mon, QOBJECT(qmp));
379
    QDECREF(qmp);
380
}
381

    
382
static void timestamp_put(QDict *qdict)
383
{
384
    int err;
385
    QObject *obj;
386
    qemu_timeval tv;
387

    
388
    err = qemu_gettimeofday(&tv);
389
    if (err < 0)
390
        return;
391

    
392
    obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
393
                                "'microseconds': %" PRId64 " }",
394
                                (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
395
    qdict_put_obj(qdict, "timestamp", obj);
396
}
397

    
398
/**
399
 * monitor_protocol_event(): Generate a Monitor event
400
 *
401
 * Event-specific data can be emitted through the (optional) 'data' parameter.
402
 */
403
void monitor_protocol_event(MonitorEvent event, QObject *data)
404
{
405
    QDict *qmp;
406
    const char *event_name;
407
    Monitor *mon;
408

    
409
    assert(event < QEVENT_MAX);
410

    
411
    switch (event) {
412
        case QEVENT_SHUTDOWN:
413
            event_name = "SHUTDOWN";
414
            break;
415
        case QEVENT_RESET:
416
            event_name = "RESET";
417
            break;
418
        case QEVENT_POWERDOWN:
419
            event_name = "POWERDOWN";
420
            break;
421
        case QEVENT_STOP:
422
            event_name = "STOP";
423
            break;
424
        case QEVENT_VNC_CONNECTED:
425
            event_name = "VNC_CONNECTED";
426
            break;
427
        case QEVENT_VNC_INITIALIZED:
428
            event_name = "VNC_INITIALIZED";
429
            break;
430
        case QEVENT_VNC_DISCONNECTED:
431
            event_name = "VNC_DISCONNECTED";
432
            break;
433
        case QEVENT_BLOCK_IO_ERROR:
434
            event_name = "BLOCK_IO_ERROR";
435
            break;
436
        case QEVENT_RTC_CHANGE:
437
            event_name = "RTC_CHANGE";
438
            break;
439
        case QEVENT_WATCHDOG:
440
            event_name = "WATCHDOG";
441
            break;
442
        default:
443
            abort();
444
            break;
445
    }
446

    
447
    qmp = qdict_new();
448
    timestamp_put(qmp);
449
    qdict_put(qmp, "event", qstring_from_str(event_name));
450
    if (data) {
451
        qobject_incref(data);
452
        qdict_put_obj(qmp, "data", data);
453
    }
454

    
455
    QLIST_FOREACH(mon, &mon_list, entry) {
456
        if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
457
            monitor_json_emitter(mon, QOBJECT(qmp));
458
        }
459
    }
460
    QDECREF(qmp);
461
}
462

    
463
static int do_qmp_capabilities(Monitor *mon, const QDict *params,
464
                               QObject **ret_data)
465
{
466
    /* Will setup QMP capabilities in the future */
467
    if (monitor_ctrl_mode(mon)) {
468
        mon->mc->command_mode = 1;
469
    }
470

    
471
    return 0;
472
}
473

    
474
static int compare_cmd(const char *name, const char *list)
475
{
476
    const char *p, *pstart;
477
    int len;
478
    len = strlen(name);
479
    p = list;
480
    for(;;) {
481
        pstart = p;
482
        p = strchr(p, '|');
483
        if (!p)
484
            p = pstart + strlen(pstart);
485
        if ((p - pstart) == len && !memcmp(pstart, name, len))
486
            return 1;
487
        if (*p == '\0')
488
            break;
489
        p++;
490
    }
491
    return 0;
492
}
493

    
494
static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
495
                          const char *prefix, const char *name)
496
{
497
    const mon_cmd_t *cmd;
498

    
499
    for(cmd = cmds; cmd->name != NULL; cmd++) {
500
        if (!name || !strcmp(name, cmd->name))
501
            monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
502
                           cmd->params, cmd->help);
503
    }
504
}
505

    
506
static void help_cmd(Monitor *mon, const char *name)
507
{
508
    if (name && !strcmp(name, "info")) {
509
        help_cmd_dump(mon, info_cmds, "info ", NULL);
510
    } else {
511
        help_cmd_dump(mon, mon_cmds, "", name);
512
        if (name && !strcmp(name, "log")) {
513
            const CPULogItem *item;
514
            monitor_printf(mon, "Log items (comma separated):\n");
515
            monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
516
            for(item = cpu_log_items; item->mask != 0; item++) {
517
                monitor_printf(mon, "%-10s %s\n", item->name, item->help);
518
            }
519
        }
520
    }
521
}
522

    
523
static void do_help_cmd(Monitor *mon, const QDict *qdict)
524
{
525
    help_cmd(mon, qdict_get_try_str(qdict, "name"));
526
}
527

    
528
static void do_commit(Monitor *mon, const QDict *qdict)
529
{
530
    int all_devices;
531
    DriveInfo *dinfo;
532
    const char *device = qdict_get_str(qdict, "device");
533

    
534
    all_devices = !strcmp(device, "all");
535
    QTAILQ_FOREACH(dinfo, &drives, next) {
536
        if (!all_devices)
537
            if (strcmp(bdrv_get_device_name(dinfo->bdrv), device))
538
                continue;
539
        bdrv_commit(dinfo->bdrv);
540
    }
541
}
542

    
543
static void user_monitor_complete(void *opaque, QObject *ret_data)
544
{
545
    MonitorCompletionData *data = (MonitorCompletionData *)opaque; 
546

    
547
    if (ret_data) {
548
        data->user_print(data->mon, ret_data);
549
    }
550
    monitor_resume(data->mon);
551
    qemu_free(data);
552
}
553

    
554
static void qmp_monitor_complete(void *opaque, QObject *ret_data)
555
{
556
    monitor_protocol_emitter(opaque, ret_data);
557
}
558

    
559
static void qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
560
                                  const QDict *params)
561
{
562
    cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
563
}
564

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

    
570
static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
571
                                   const QDict *params)
572
{
573
    int ret;
574

    
575
    MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
576
    cb_data->mon = mon;
577
    cb_data->user_print = cmd->user_print;
578
    monitor_suspend(mon);
579
    ret = cmd->mhandler.cmd_async(mon, params,
580
                                  user_monitor_complete, cb_data);
581
    if (ret < 0) {
582
        monitor_resume(mon);
583
        qemu_free(cb_data);
584
    }
585
}
586

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

    
591
    MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
592
    cb_data->mon = mon;
593
    cb_data->user_print = cmd->user_print;
594
    monitor_suspend(mon);
595
    ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);
596
    if (ret < 0) {
597
        monitor_resume(mon);
598
        qemu_free(cb_data);
599
    }
600
}
601

    
602
static int do_info(Monitor *mon, const QDict *qdict, QObject **ret_data)
603
{
604
    const mon_cmd_t *cmd;
605
    const char *item = qdict_get_try_str(qdict, "item");
606

    
607
    if (!item) {
608
        assert(monitor_ctrl_mode(mon) == 0);
609
        goto help;
610
    }
611

    
612
    for (cmd = info_cmds; cmd->name != NULL; cmd++) {
613
        if (compare_cmd(item, cmd->name))
614
            break;
615
    }
616

    
617
    if (cmd->name == NULL) {
618
        if (monitor_ctrl_mode(mon)) {
619
            qerror_report(QERR_COMMAND_NOT_FOUND, item);
620
            return -1;
621
        }
622
        goto help;
623
    }
624

    
625
    if (monitor_handler_is_async(cmd)) {
626
        if (monitor_ctrl_mode(mon)) {
627
            qmp_async_info_handler(mon, cmd);
628
        } else {
629
            user_async_info_handler(mon, cmd);
630
        }
631
        /*
632
         * Indicate that this command is asynchronous and will not return any
633
         * data (not even empty).  Instead, the data will be returned via a
634
         * completion callback.
635
         */
636
        *ret_data = qobject_from_jsonf("{ '__mon_async': 'return' }");
637
    } else if (monitor_handler_ported(cmd)) {
638
        cmd->mhandler.info_new(mon, ret_data);
639

    
640
        if (!monitor_ctrl_mode(mon)) {
641
            /*
642
             * User Protocol function is called here, Monitor Protocol is
643
             * handled by monitor_call_handler()
644
             */
645
            if (*ret_data)
646
                cmd->user_print(mon, *ret_data);
647
        }
648
    } else {
649
        if (monitor_ctrl_mode(mon)) {
650
            /* handler not converted yet */
651
            qerror_report(QERR_COMMAND_NOT_FOUND, item);
652
            return -1;
653
        } else {
654
            cmd->mhandler.info(mon);
655
        }
656
    }
657

    
658
    return 0;
659

    
660
help:
661
    help_cmd(mon, "info");
662
    return 0;
663
}
664

    
665
static void do_info_version_print(Monitor *mon, const QObject *data)
666
{
667
    QDict *qdict;
668

    
669
    qdict = qobject_to_qdict(data);
670

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

    
675
/**
676
 * do_info_version(): Show QEMU version
677
 *
678
 * Return a QDict with the following information:
679
 *
680
 * - "qemu": QEMU's version
681
 * - "package": package's version
682
 *
683
 * Example:
684
 *
685
 * { "qemu": "0.11.50", "package": "" }
686
 */
687
static void do_info_version(Monitor *mon, QObject **ret_data)
688
{
689
    *ret_data = qobject_from_jsonf("{ 'qemu': %s, 'package': %s }",
690
                                   QEMU_VERSION, QEMU_PKGVERSION);
691
}
692

    
693
static void do_info_name_print(Monitor *mon, const QObject *data)
694
{
695
    QDict *qdict;
696

    
697
    qdict = qobject_to_qdict(data);
698
    if (qdict_size(qdict) == 0) {
699
        return;
700
    }
701

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

    
705
/**
706
 * do_info_name(): Show VM name
707
 *
708
 * Return a QDict with the following information:
709
 *
710
 * - "name": VM's name (optional)
711
 *
712
 * Example:
713
 *
714
 * { "name": "qemu-name" }
715
 */
716
static void do_info_name(Monitor *mon, QObject **ret_data)
717
{
718
    *ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :
719
                            qobject_from_jsonf("{}");
720
}
721

    
722
static QObject *get_cmd_dict(const char *name)
723
{
724
    const char *p;
725

    
726
    /* Remove '|' from some commands */
727
    p = strchr(name, '|');
728
    if (p) {
729
        p++;
730
    } else {
731
        p = name;
732
    }
733

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

    
737
/**
738
 * do_info_commands(): List QMP available commands
739
 *
740
 * Each command is represented by a QDict, the returned QObject is a QList
741
 * of all commands.
742
 *
743
 * The QDict contains:
744
 *
745
 * - "name": command's name
746
 *
747
 * Example:
748
 *
749
 * { [ { "name": "query-balloon" }, { "name": "system_powerdown" } ] }
750
 */
751
static void do_info_commands(Monitor *mon, QObject **ret_data)
752
{
753
    QList *cmd_list;
754
    const mon_cmd_t *cmd;
755

    
756
    cmd_list = qlist_new();
757

    
758
    for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
759
        if (monitor_handler_ported(cmd) && !compare_cmd(cmd->name, "info")) {
760
            qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));
761
        }
762
    }
763

    
764
    for (cmd = info_cmds; cmd->name != NULL; cmd++) {
765
        if (monitor_handler_ported(cmd)) {
766
            char buf[128];
767
            snprintf(buf, sizeof(buf), "query-%s", cmd->name);
768
            qlist_append_obj(cmd_list, get_cmd_dict(buf));
769
        }
770
    }
771

    
772
    *ret_data = QOBJECT(cmd_list);
773
}
774

    
775
#if defined(TARGET_I386)
776
static void do_info_hpet_print(Monitor *mon, const QObject *data)
777
{
778
    monitor_printf(mon, "HPET is %s by QEMU\n",
779
                   qdict_get_bool(qobject_to_qdict(data), "enabled") ?
780
                   "enabled" : "disabled");
781
}
782

    
783
/**
784
 * do_info_hpet(): Show HPET state
785
 *
786
 * Return a QDict with the following information:
787
 *
788
 * - "enabled": true if hpet if enabled, false otherwise
789
 *
790
 * Example:
791
 *
792
 * { "enabled": true }
793
 */
794
static void do_info_hpet(Monitor *mon, QObject **ret_data)
795
{
796
    *ret_data = qobject_from_jsonf("{ 'enabled': %i }", !no_hpet);
797
}
798
#endif
799

    
800
static void do_info_uuid_print(Monitor *mon, const QObject *data)
801
{
802
    monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));
803
}
804

    
805
/**
806
 * do_info_uuid(): Show VM UUID
807
 *
808
 * Return a QDict with the following information:
809
 *
810
 * - "UUID": Universally Unique Identifier
811
 *
812
 * Example:
813
 *
814
 * { "UUID": "550e8400-e29b-41d4-a716-446655440000" }
815
 */
816
static void do_info_uuid(Monitor *mon, QObject **ret_data)
817
{
818
    char uuid[64];
819

    
820
    snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
821
                   qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
822
                   qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
823
                   qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
824
                   qemu_uuid[14], qemu_uuid[15]);
825
    *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);
826
}
827

    
828
/* get the current CPU defined by the user */
829
static int mon_set_cpu(int cpu_index)
830
{
831
    CPUState *env;
832

    
833
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
834
        if (env->cpu_index == cpu_index) {
835
            cur_mon->mon_cpu = env;
836
            return 0;
837
        }
838
    }
839
    return -1;
840
}
841

    
842
static CPUState *mon_get_cpu(void)
843
{
844
    if (!cur_mon->mon_cpu) {
845
        mon_set_cpu(0);
846
    }
847
    cpu_synchronize_state(cur_mon->mon_cpu);
848
    return cur_mon->mon_cpu;
849
}
850

    
851
static void do_info_registers(Monitor *mon)
852
{
853
    CPUState *env;
854
    env = mon_get_cpu();
855
#ifdef TARGET_I386
856
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
857
                   X86_DUMP_FPU);
858
#else
859
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
860
                   0);
861
#endif
862
}
863

    
864
static void print_cpu_iter(QObject *obj, void *opaque)
865
{
866
    QDict *cpu;
867
    int active = ' ';
868
    Monitor *mon = opaque;
869

    
870
    assert(qobject_type(obj) == QTYPE_QDICT);
871
    cpu = qobject_to_qdict(obj);
872

    
873
    if (qdict_get_bool(cpu, "current")) {
874
        active = '*';
875
    }
876

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

    
879
#if defined(TARGET_I386)
880
    monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
881
                   (target_ulong) qdict_get_int(cpu, "pc"));
882
#elif defined(TARGET_PPC)
883
    monitor_printf(mon, "nip=0x" TARGET_FMT_lx,
884
                   (target_long) qdict_get_int(cpu, "nip"));
885
#elif defined(TARGET_SPARC)
886
    monitor_printf(mon, "pc=0x " TARGET_FMT_lx,
887
                   (target_long) qdict_get_int(cpu, "pc"));
888
    monitor_printf(mon, "npc=0x" TARGET_FMT_lx,
889
                   (target_long) qdict_get_int(cpu, "npc"));
890
#elif defined(TARGET_MIPS)
891
    monitor_printf(mon, "PC=0x" TARGET_FMT_lx,
892
                   (target_long) qdict_get_int(cpu, "PC"));
893
#endif
894

    
895
    if (qdict_get_bool(cpu, "halted")) {
896
        monitor_printf(mon, " (halted)");
897
    }
898

    
899
    monitor_printf(mon, "\n");
900
}
901

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

    
906
    assert(qobject_type(data) == QTYPE_QLIST);
907
    cpu_list = qobject_to_qlist(data);
908
    qlist_iter(cpu_list, print_cpu_iter, mon);
909
}
910

    
911
/**
912
 * do_info_cpus(): Show CPU information
913
 *
914
 * Return a QList. Each CPU is represented by a QDict, which contains:
915
 *
916
 * - "cpu": CPU index
917
 * - "current": true if this is the current CPU, false otherwise
918
 * - "halted": true if the cpu is halted, false otherwise
919
 * - Current program counter. The key's name depends on the architecture:
920
 *      "pc": i386/x86)64
921
 *      "nip": PPC
922
 *      "pc" and "npc": sparc
923
 *      "PC": mips
924
 *
925
 * Example:
926
 *
927
 * [ { "CPU": 0, "current": true, "halted": false, "pc": 3227107138 },
928
 *   { "CPU": 1, "current": false, "halted": true, "pc": 7108165 } ]
929
 */
930
static void do_info_cpus(Monitor *mon, QObject **ret_data)
931
{
932
    CPUState *env;
933
    QList *cpu_list;
934

    
935
    cpu_list = qlist_new();
936

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

    
940
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
941
        QDict *cpu;
942
        QObject *obj;
943

    
944
        cpu_synchronize_state(env);
945

    
946
        obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",
947
                                 env->cpu_index, env == mon->mon_cpu,
948
                                 env->halted);
949

    
950
        cpu = qobject_to_qdict(obj);
951

    
952
#if defined(TARGET_I386)
953
        qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));
954
#elif defined(TARGET_PPC)
955
        qdict_put(cpu, "nip", qint_from_int(env->nip));
956
#elif defined(TARGET_SPARC)
957
        qdict_put(cpu, "pc", qint_from_int(env->pc));
958
        qdict_put(cpu, "npc", qint_from_int(env->npc));
959
#elif defined(TARGET_MIPS)
960
        qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));
961
#endif
962

    
963
        qlist_append(cpu_list, cpu);
964
    }
965

    
966
    *ret_data = QOBJECT(cpu_list);
967
}
968

    
969
static int do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)
970
{
971
    int index = qdict_get_int(qdict, "index");
972
    if (mon_set_cpu(index) < 0) {
973
        qerror_report(QERR_INVALID_PARAMETER, "index");
974
        return -1;
975
    }
976
    return 0;
977
}
978

    
979
static void do_info_jit(Monitor *mon)
980
{
981
    dump_exec_info((FILE *)mon, monitor_fprintf);
982
}
983

    
984
static void do_info_history(Monitor *mon)
985
{
986
    int i;
987
    const char *str;
988

    
989
    if (!mon->rs)
990
        return;
991
    i = 0;
992
    for(;;) {
993
        str = readline_get_history(mon->rs, i);
994
        if (!str)
995
            break;
996
        monitor_printf(mon, "%d: '%s'\n", i, str);
997
        i++;
998
    }
999
}
1000

    
1001
#if defined(TARGET_PPC)
1002
/* XXX: not implemented in other targets */
1003
static void do_info_cpu_stats(Monitor *mon)
1004
{
1005
    CPUState *env;
1006

    
1007
    env = mon_get_cpu();
1008
    cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
1009
}
1010
#endif
1011

    
1012
/**
1013
 * do_quit(): Quit QEMU execution
1014
 */
1015
static int do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
1016
{
1017
    exit(0);
1018
    return 0;
1019
}
1020

    
1021
static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
1022
{
1023
    if (bdrv_is_inserted(bs)) {
1024
        if (!force) {
1025
            if (!bdrv_is_removable(bs)) {
1026
                qerror_report(QERR_DEVICE_NOT_REMOVABLE,
1027
                               bdrv_get_device_name(bs));
1028
                return -1;
1029
            }
1030
            if (bdrv_is_locked(bs)) {
1031
                qerror_report(QERR_DEVICE_LOCKED, bdrv_get_device_name(bs));
1032
                return -1;
1033
            }
1034
        }
1035
        bdrv_close(bs);
1036
    }
1037
    return 0;
1038
}
1039

    
1040
static int do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data)
1041
{
1042
    BlockDriverState *bs;
1043
    int force = qdict_get_int(qdict, "force");
1044
    const char *filename = qdict_get_str(qdict, "device");
1045

    
1046
    bs = bdrv_find(filename);
1047
    if (!bs) {
1048
        qerror_report(QERR_DEVICE_NOT_FOUND, filename);
1049
        return -1;
1050
    }
1051
    return eject_device(mon, bs, force);
1052
}
1053

    
1054
static int do_block_set_passwd(Monitor *mon, const QDict *qdict,
1055
                                QObject **ret_data)
1056
{
1057
    BlockDriverState *bs;
1058
    int err;
1059

    
1060
    bs = bdrv_find(qdict_get_str(qdict, "device"));
1061
    if (!bs) {
1062
        qerror_report(QERR_DEVICE_NOT_FOUND, qdict_get_str(qdict, "device"));
1063
        return -1;
1064
    }
1065

    
1066
    err = bdrv_set_key(bs, qdict_get_str(qdict, "password"));
1067
    if (err == -EINVAL) {
1068
        qerror_report(QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs));
1069
        return -1;
1070
    } else if (err < 0) {
1071
        qerror_report(QERR_INVALID_PASSWORD);
1072
        return -1;
1073
    }
1074

    
1075
    return 0;
1076
}
1077

    
1078
static int do_change_block(Monitor *mon, const char *device,
1079
                           const char *filename, const char *fmt)
1080
{
1081
    BlockDriverState *bs;
1082
    BlockDriver *drv = NULL;
1083

    
1084
    bs = bdrv_find(device);
1085
    if (!bs) {
1086
        qerror_report(QERR_DEVICE_NOT_FOUND, device);
1087
        return -1;
1088
    }
1089
    if (fmt) {
1090
        drv = bdrv_find_whitelisted_format(fmt);
1091
        if (!drv) {
1092
            qerror_report(QERR_INVALID_BLOCK_FORMAT, fmt);
1093
            return -1;
1094
        }
1095
    }
1096
    if (eject_device(mon, bs, 0) < 0) {
1097
        return -1;
1098
    }
1099
    if (bdrv_open2(bs, filename, BDRV_O_RDWR, drv) < 0) {
1100
        return -1;
1101
    }
1102
    return monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
1103
}
1104

    
1105
static int change_vnc_password(const char *password)
1106
{
1107
    if (vnc_display_password(NULL, password) < 0) {
1108
        qerror_report(QERR_SET_PASSWD_FAILED);
1109
        return -1;
1110
    }
1111

    
1112
    return 0;
1113
}
1114

    
1115
static void change_vnc_password_cb(Monitor *mon, const char *password,
1116
                                   void *opaque)
1117
{
1118
    change_vnc_password(password);
1119
    monitor_read_command(mon, 1);
1120
}
1121

    
1122
static int do_change_vnc(Monitor *mon, const char *target, const char *arg)
1123
{
1124
    if (strcmp(target, "passwd") == 0 ||
1125
        strcmp(target, "password") == 0) {
1126
        if (arg) {
1127
            char password[9];
1128
            strncpy(password, arg, sizeof(password));
1129
            password[sizeof(password) - 1] = '\0';
1130
            return change_vnc_password(password);
1131
        } else {
1132
            return monitor_read_password(mon, change_vnc_password_cb, NULL);
1133
        }
1134
    } else {
1135
        if (vnc_display_open(NULL, target) < 0) {
1136
            qerror_report(QERR_VNC_SERVER_FAILED, target);
1137
            return -1;
1138
        }
1139
    }
1140

    
1141
    return 0;
1142
}
1143

    
1144
/**
1145
 * do_change(): Change a removable medium, or VNC configuration
1146
 */
1147
static int do_change(Monitor *mon, const QDict *qdict, QObject **ret_data)
1148
{
1149
    const char *device = qdict_get_str(qdict, "device");
1150
    const char *target = qdict_get_str(qdict, "target");
1151
    const char *arg = qdict_get_try_str(qdict, "arg");
1152
    int ret;
1153

    
1154
    if (strcmp(device, "vnc") == 0) {
1155
        ret = do_change_vnc(mon, target, arg);
1156
    } else {
1157
        ret = do_change_block(mon, device, target, arg);
1158
    }
1159

    
1160
    return ret;
1161
}
1162

    
1163
static void do_screen_dump(Monitor *mon, const QDict *qdict)
1164
{
1165
    vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
1166
}
1167

    
1168
static void do_logfile(Monitor *mon, const QDict *qdict)
1169
{
1170
    cpu_set_log_filename(qdict_get_str(qdict, "filename"));
1171
}
1172

    
1173
static void do_log(Monitor *mon, const QDict *qdict)
1174
{
1175
    int mask;
1176
    const char *items = qdict_get_str(qdict, "items");
1177

    
1178
    if (!strcmp(items, "none")) {
1179
        mask = 0;
1180
    } else {
1181
        mask = cpu_str_to_log_mask(items);
1182
        if (!mask) {
1183
            help_cmd(mon, "log");
1184
            return;
1185
        }
1186
    }
1187
    cpu_set_log(mask);
1188
}
1189

    
1190
static void do_singlestep(Monitor *mon, const QDict *qdict)
1191
{
1192
    const char *option = qdict_get_try_str(qdict, "option");
1193
    if (!option || !strcmp(option, "on")) {
1194
        singlestep = 1;
1195
    } else if (!strcmp(option, "off")) {
1196
        singlestep = 0;
1197
    } else {
1198
        monitor_printf(mon, "unexpected option %s\n", option);
1199
    }
1200
}
1201

    
1202
/**
1203
 * do_stop(): Stop VM execution
1204
 */
1205
static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
1206
{
1207
    vm_stop(EXCP_INTERRUPT);
1208
    return 0;
1209
}
1210

    
1211
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
1212

    
1213
struct bdrv_iterate_context {
1214
    Monitor *mon;
1215
    int err;
1216
};
1217

    
1218
/**
1219
 * do_cont(): Resume emulation.
1220
 */
1221
static int do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
1222
{
1223
    struct bdrv_iterate_context context = { mon, 0 };
1224

    
1225
    bdrv_iterate(encrypted_bdrv_it, &context);
1226
    /* only resume the vm if all keys are set and valid */
1227
    if (!context.err) {
1228
        vm_start();
1229
        return 0;
1230
    } else {
1231
        return -1;
1232
    }
1233
}
1234

    
1235
static void bdrv_key_cb(void *opaque, int err)
1236
{
1237
    Monitor *mon = opaque;
1238

    
1239
    /* another key was set successfully, retry to continue */
1240
    if (!err)
1241
        do_cont(mon, NULL, NULL);
1242
}
1243

    
1244
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
1245
{
1246
    struct bdrv_iterate_context *context = opaque;
1247

    
1248
    if (!context->err && bdrv_key_required(bs)) {
1249
        context->err = -EBUSY;
1250
        monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
1251
                                    context->mon);
1252
    }
1253
}
1254

    
1255
static void do_gdbserver(Monitor *mon, const QDict *qdict)
1256
{
1257
    const char *device = qdict_get_try_str(qdict, "device");
1258
    if (!device)
1259
        device = "tcp::" DEFAULT_GDBSTUB_PORT;
1260
    if (gdbserver_start(device) < 0) {
1261
        monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1262
                       device);
1263
    } else if (strcmp(device, "none") == 0) {
1264
        monitor_printf(mon, "Disabled gdbserver\n");
1265
    } else {
1266
        monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1267
                       device);
1268
    }
1269
}
1270

    
1271
static void do_watchdog_action(Monitor *mon, const QDict *qdict)
1272
{
1273
    const char *action = qdict_get_str(qdict, "action");
1274
    if (select_watchdog_action(action) == -1) {
1275
        monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1276
    }
1277
}
1278

    
1279
static void monitor_printc(Monitor *mon, int c)
1280
{
1281
    monitor_printf(mon, "'");
1282
    switch(c) {
1283
    case '\'':
1284
        monitor_printf(mon, "\\'");
1285
        break;
1286
    case '\\':
1287
        monitor_printf(mon, "\\\\");
1288
        break;
1289
    case '\n':
1290
        monitor_printf(mon, "\\n");
1291
        break;
1292
    case '\r':
1293
        monitor_printf(mon, "\\r");
1294
        break;
1295
    default:
1296
        if (c >= 32 && c <= 126) {
1297
            monitor_printf(mon, "%c", c);
1298
        } else {
1299
            monitor_printf(mon, "\\x%02x", c);
1300
        }
1301
        break;
1302
    }
1303
    monitor_printf(mon, "'");
1304
}
1305

    
1306
static void memory_dump(Monitor *mon, int count, int format, int wsize,
1307
                        target_phys_addr_t addr, int is_physical)
1308
{
1309
    CPUState *env;
1310
    int l, line_size, i, max_digits, len;
1311
    uint8_t buf[16];
1312
    uint64_t v;
1313

    
1314
    if (format == 'i') {
1315
        int flags;
1316
        flags = 0;
1317
        env = mon_get_cpu();
1318
#ifdef TARGET_I386
1319
        if (wsize == 2) {
1320
            flags = 1;
1321
        } else if (wsize == 4) {
1322
            flags = 0;
1323
        } else {
1324
            /* as default we use the current CS size */
1325
            flags = 0;
1326
            if (env) {
1327
#ifdef TARGET_X86_64
1328
                if ((env->efer & MSR_EFER_LMA) &&
1329
                    (env->segs[R_CS].flags & DESC_L_MASK))
1330
                    flags = 2;
1331
                else
1332
#endif
1333
                if (!(env->segs[R_CS].flags & DESC_B_MASK))
1334
                    flags = 1;
1335
            }
1336
        }
1337
#endif
1338
        monitor_disas(mon, env, addr, count, is_physical, flags);
1339
        return;
1340
    }
1341

    
1342
    len = wsize * count;
1343
    if (wsize == 1)
1344
        line_size = 8;
1345
    else
1346
        line_size = 16;
1347
    max_digits = 0;
1348

    
1349
    switch(format) {
1350
    case 'o':
1351
        max_digits = (wsize * 8 + 2) / 3;
1352
        break;
1353
    default:
1354
    case 'x':
1355
        max_digits = (wsize * 8) / 4;
1356
        break;
1357
    case 'u':
1358
    case 'd':
1359
        max_digits = (wsize * 8 * 10 + 32) / 33;
1360
        break;
1361
    case 'c':
1362
        wsize = 1;
1363
        break;
1364
    }
1365

    
1366
    while (len > 0) {
1367
        if (is_physical)
1368
            monitor_printf(mon, TARGET_FMT_plx ":", addr);
1369
        else
1370
            monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1371
        l = len;
1372
        if (l > line_size)
1373
            l = line_size;
1374
        if (is_physical) {
1375
            cpu_physical_memory_rw(addr, buf, l, 0);
1376
        } else {
1377
            env = mon_get_cpu();
1378
            if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
1379
                monitor_printf(mon, " Cannot access memory\n");
1380
                break;
1381
            }
1382
        }
1383
        i = 0;
1384
        while (i < l) {
1385
            switch(wsize) {
1386
            default:
1387
            case 1:
1388
                v = ldub_raw(buf + i);
1389
                break;
1390
            case 2:
1391
                v = lduw_raw(buf + i);
1392
                break;
1393
            case 4:
1394
                v = (uint32_t)ldl_raw(buf + i);
1395
                break;
1396
            case 8:
1397
                v = ldq_raw(buf + i);
1398
                break;
1399
            }
1400
            monitor_printf(mon, " ");
1401
            switch(format) {
1402
            case 'o':
1403
                monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1404
                break;
1405
            case 'x':
1406
                monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1407
                break;
1408
            case 'u':
1409
                monitor_printf(mon, "%*" PRIu64, max_digits, v);
1410
                break;
1411
            case 'd':
1412
                monitor_printf(mon, "%*" PRId64, max_digits, v);
1413
                break;
1414
            case 'c':
1415
                monitor_printc(mon, v);
1416
                break;
1417
            }
1418
            i += wsize;
1419
        }
1420
        monitor_printf(mon, "\n");
1421
        addr += l;
1422
        len -= l;
1423
    }
1424
}
1425

    
1426
static void do_memory_dump(Monitor *mon, const QDict *qdict)
1427
{
1428
    int count = qdict_get_int(qdict, "count");
1429
    int format = qdict_get_int(qdict, "format");
1430
    int size = qdict_get_int(qdict, "size");
1431
    target_long addr = qdict_get_int(qdict, "addr");
1432

    
1433
    memory_dump(mon, count, format, size, addr, 0);
1434
}
1435

    
1436
static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
1437
{
1438
    int count = qdict_get_int(qdict, "count");
1439
    int format = qdict_get_int(qdict, "format");
1440
    int size = qdict_get_int(qdict, "size");
1441
    target_phys_addr_t addr = qdict_get_int(qdict, "addr");
1442

    
1443
    memory_dump(mon, count, format, size, addr, 1);
1444
}
1445

    
1446
static void do_print(Monitor *mon, const QDict *qdict)
1447
{
1448
    int format = qdict_get_int(qdict, "format");
1449
    target_phys_addr_t val = qdict_get_int(qdict, "val");
1450

    
1451
#if TARGET_PHYS_ADDR_BITS == 32
1452
    switch(format) {
1453
    case 'o':
1454
        monitor_printf(mon, "%#o", val);
1455
        break;
1456
    case 'x':
1457
        monitor_printf(mon, "%#x", val);
1458
        break;
1459
    case 'u':
1460
        monitor_printf(mon, "%u", val);
1461
        break;
1462
    default:
1463
    case 'd':
1464
        monitor_printf(mon, "%d", val);
1465
        break;
1466
    case 'c':
1467
        monitor_printc(mon, val);
1468
        break;
1469
    }
1470
#else
1471
    switch(format) {
1472
    case 'o':
1473
        monitor_printf(mon, "%#" PRIo64, val);
1474
        break;
1475
    case 'x':
1476
        monitor_printf(mon, "%#" PRIx64, val);
1477
        break;
1478
    case 'u':
1479
        monitor_printf(mon, "%" PRIu64, val);
1480
        break;
1481
    default:
1482
    case 'd':
1483
        monitor_printf(mon, "%" PRId64, val);
1484
        break;
1485
    case 'c':
1486
        monitor_printc(mon, val);
1487
        break;
1488
    }
1489
#endif
1490
    monitor_printf(mon, "\n");
1491
}
1492

    
1493
static int do_memory_save(Monitor *mon, const QDict *qdict, QObject **ret_data)
1494
{
1495
    FILE *f;
1496
    uint32_t size = qdict_get_int(qdict, "size");
1497
    const char *filename = qdict_get_str(qdict, "filename");
1498
    target_long addr = qdict_get_int(qdict, "val");
1499
    uint32_t l;
1500
    CPUState *env;
1501
    uint8_t buf[1024];
1502
    int ret = -1;
1503

    
1504
    env = mon_get_cpu();
1505

    
1506
    f = fopen(filename, "wb");
1507
    if (!f) {
1508
        qerror_report(QERR_OPEN_FILE_FAILED, filename);
1509
        return -1;
1510
    }
1511
    while (size != 0) {
1512
        l = sizeof(buf);
1513
        if (l > size)
1514
            l = size;
1515
        cpu_memory_rw_debug(env, addr, buf, l, 0);
1516
        if (fwrite(buf, 1, l, f) != l) {
1517
            monitor_printf(mon, "fwrite() error in do_memory_save\n");
1518
            goto exit;
1519
        }
1520
        addr += l;
1521
        size -= l;
1522
    }
1523

    
1524
    ret = 0;
1525

    
1526
exit:
1527
    fclose(f);
1528
    return ret;
1529
}
1530

    
1531
static int do_physical_memory_save(Monitor *mon, const QDict *qdict,
1532
                                    QObject **ret_data)
1533
{
1534
    FILE *f;
1535
    uint32_t l;
1536
    uint8_t buf[1024];
1537
    uint32_t size = qdict_get_int(qdict, "size");
1538
    const char *filename = qdict_get_str(qdict, "filename");
1539
    target_phys_addr_t addr = qdict_get_int(qdict, "val");
1540
    int ret = -1;
1541

    
1542
    f = fopen(filename, "wb");
1543
    if (!f) {
1544
        qerror_report(QERR_OPEN_FILE_FAILED, filename);
1545
        return -1;
1546
    }
1547
    while (size != 0) {
1548
        l = sizeof(buf);
1549
        if (l > size)
1550
            l = size;
1551
        cpu_physical_memory_rw(addr, buf, l, 0);
1552
        if (fwrite(buf, 1, l, f) != l) {
1553
            monitor_printf(mon, "fwrite() error in do_physical_memory_save\n");
1554
            goto exit;
1555
        }
1556
        fflush(f);
1557
        addr += l;
1558
        size -= l;
1559
    }
1560

    
1561
    ret = 0;
1562

    
1563
exit:
1564
    fclose(f);
1565
    return ret;
1566
}
1567

    
1568
static void do_sum(Monitor *mon, const QDict *qdict)
1569
{
1570
    uint32_t addr;
1571
    uint8_t buf[1];
1572
    uint16_t sum;
1573
    uint32_t start = qdict_get_int(qdict, "start");
1574
    uint32_t size = qdict_get_int(qdict, "size");
1575

    
1576
    sum = 0;
1577
    for(addr = start; addr < (start + size); addr++) {
1578
        cpu_physical_memory_rw(addr, buf, 1, 0);
1579
        /* BSD sum algorithm ('sum' Unix command) */
1580
        sum = (sum >> 1) | (sum << 15);
1581
        sum += buf[0];
1582
    }
1583
    monitor_printf(mon, "%05d\n", sum);
1584
}
1585

    
1586
typedef struct {
1587
    int keycode;
1588
    const char *name;
1589
} KeyDef;
1590

    
1591
static const KeyDef key_defs[] = {
1592
    { 0x2a, "shift" },
1593
    { 0x36, "shift_r" },
1594

    
1595
    { 0x38, "alt" },
1596
    { 0xb8, "alt_r" },
1597
    { 0x64, "altgr" },
1598
    { 0xe4, "altgr_r" },
1599
    { 0x1d, "ctrl" },
1600
    { 0x9d, "ctrl_r" },
1601

    
1602
    { 0xdd, "menu" },
1603

    
1604
    { 0x01, "esc" },
1605

    
1606
    { 0x02, "1" },
1607
    { 0x03, "2" },
1608
    { 0x04, "3" },
1609
    { 0x05, "4" },
1610
    { 0x06, "5" },
1611
    { 0x07, "6" },
1612
    { 0x08, "7" },
1613
    { 0x09, "8" },
1614
    { 0x0a, "9" },
1615
    { 0x0b, "0" },
1616
    { 0x0c, "minus" },
1617
    { 0x0d, "equal" },
1618
    { 0x0e, "backspace" },
1619

    
1620
    { 0x0f, "tab" },
1621
    { 0x10, "q" },
1622
    { 0x11, "w" },
1623
    { 0x12, "e" },
1624
    { 0x13, "r" },
1625
    { 0x14, "t" },
1626
    { 0x15, "y" },
1627
    { 0x16, "u" },
1628
    { 0x17, "i" },
1629
    { 0x18, "o" },
1630
    { 0x19, "p" },
1631

    
1632
    { 0x1c, "ret" },
1633

    
1634
    { 0x1e, "a" },
1635
    { 0x1f, "s" },
1636
    { 0x20, "d" },
1637
    { 0x21, "f" },
1638
    { 0x22, "g" },
1639
    { 0x23, "h" },
1640
    { 0x24, "j" },
1641
    { 0x25, "k" },
1642
    { 0x26, "l" },
1643

    
1644
    { 0x2c, "z" },
1645
    { 0x2d, "x" },
1646
    { 0x2e, "c" },
1647
    { 0x2f, "v" },
1648
    { 0x30, "b" },
1649
    { 0x31, "n" },
1650
    { 0x32, "m" },
1651
    { 0x33, "comma" },
1652
    { 0x34, "dot" },
1653
    { 0x35, "slash" },
1654

    
1655
    { 0x37, "asterisk" },
1656

    
1657
    { 0x39, "spc" },
1658
    { 0x3a, "caps_lock" },
1659
    { 0x3b, "f1" },
1660
    { 0x3c, "f2" },
1661
    { 0x3d, "f3" },
1662
    { 0x3e, "f4" },
1663
    { 0x3f, "f5" },
1664
    { 0x40, "f6" },
1665
    { 0x41, "f7" },
1666
    { 0x42, "f8" },
1667
    { 0x43, "f9" },
1668
    { 0x44, "f10" },
1669
    { 0x45, "num_lock" },
1670
    { 0x46, "scroll_lock" },
1671

    
1672
    { 0xb5, "kp_divide" },
1673
    { 0x37, "kp_multiply" },
1674
    { 0x4a, "kp_subtract" },
1675
    { 0x4e, "kp_add" },
1676
    { 0x9c, "kp_enter" },
1677
    { 0x53, "kp_decimal" },
1678
    { 0x54, "sysrq" },
1679

    
1680
    { 0x52, "kp_0" },
1681
    { 0x4f, "kp_1" },
1682
    { 0x50, "kp_2" },
1683
    { 0x51, "kp_3" },
1684
    { 0x4b, "kp_4" },
1685
    { 0x4c, "kp_5" },
1686
    { 0x4d, "kp_6" },
1687
    { 0x47, "kp_7" },
1688
    { 0x48, "kp_8" },
1689
    { 0x49, "kp_9" },
1690

    
1691
    { 0x56, "<" },
1692

    
1693
    { 0x57, "f11" },
1694
    { 0x58, "f12" },
1695

    
1696
    { 0xb7, "print" },
1697

    
1698
    { 0xc7, "home" },
1699
    { 0xc9, "pgup" },
1700
    { 0xd1, "pgdn" },
1701
    { 0xcf, "end" },
1702

    
1703
    { 0xcb, "left" },
1704
    { 0xc8, "up" },
1705
    { 0xd0, "down" },
1706
    { 0xcd, "right" },
1707

    
1708
    { 0xd2, "insert" },
1709
    { 0xd3, "delete" },
1710
#if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
1711
    { 0xf0, "stop" },
1712
    { 0xf1, "again" },
1713
    { 0xf2, "props" },
1714
    { 0xf3, "undo" },
1715
    { 0xf4, "front" },
1716
    { 0xf5, "copy" },
1717
    { 0xf6, "open" },
1718
    { 0xf7, "paste" },
1719
    { 0xf8, "find" },
1720
    { 0xf9, "cut" },
1721
    { 0xfa, "lf" },
1722
    { 0xfb, "help" },
1723
    { 0xfc, "meta_l" },
1724
    { 0xfd, "meta_r" },
1725
    { 0xfe, "compose" },
1726
#endif
1727
    { 0, NULL },
1728
};
1729

    
1730
static int get_keycode(const char *key)
1731
{
1732
    const KeyDef *p;
1733
    char *endp;
1734
    int ret;
1735

    
1736
    for(p = key_defs; p->name != NULL; p++) {
1737
        if (!strcmp(key, p->name))
1738
            return p->keycode;
1739
    }
1740
    if (strstart(key, "0x", NULL)) {
1741
        ret = strtoul(key, &endp, 0);
1742
        if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1743
            return ret;
1744
    }
1745
    return -1;
1746
}
1747

    
1748
#define MAX_KEYCODES 16
1749
static uint8_t keycodes[MAX_KEYCODES];
1750
static int nb_pending_keycodes;
1751
static QEMUTimer *key_timer;
1752

    
1753
static void release_keys(void *opaque)
1754
{
1755
    int keycode;
1756

    
1757
    while (nb_pending_keycodes > 0) {
1758
        nb_pending_keycodes--;
1759
        keycode = keycodes[nb_pending_keycodes];
1760
        if (keycode & 0x80)
1761
            kbd_put_keycode(0xe0);
1762
        kbd_put_keycode(keycode | 0x80);
1763
    }
1764
}
1765

    
1766
static void do_sendkey(Monitor *mon, const QDict *qdict)
1767
{
1768
    char keyname_buf[16];
1769
    char *separator;
1770
    int keyname_len, keycode, i;
1771
    const char *string = qdict_get_str(qdict, "string");
1772
    int has_hold_time = qdict_haskey(qdict, "hold_time");
1773
    int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
1774

    
1775
    if (nb_pending_keycodes > 0) {
1776
        qemu_del_timer(key_timer);
1777
        release_keys(NULL);
1778
    }
1779
    if (!has_hold_time)
1780
        hold_time = 100;
1781
    i = 0;
1782
    while (1) {
1783
        separator = strchr(string, '-');
1784
        keyname_len = separator ? separator - string : strlen(string);
1785
        if (keyname_len > 0) {
1786
            pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1787
            if (keyname_len > sizeof(keyname_buf) - 1) {
1788
                monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1789
                return;
1790
            }
1791
            if (i == MAX_KEYCODES) {
1792
                monitor_printf(mon, "too many keys\n");
1793
                return;
1794
            }
1795
            keyname_buf[keyname_len] = 0;
1796
            keycode = get_keycode(keyname_buf);
1797
            if (keycode < 0) {
1798
                monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1799
                return;
1800
            }
1801
            keycodes[i++] = keycode;
1802
        }
1803
        if (!separator)
1804
            break;
1805
        string = separator + 1;
1806
    }
1807
    nb_pending_keycodes = i;
1808
    /* key down events */
1809
    for (i = 0; i < nb_pending_keycodes; i++) {
1810
        keycode = keycodes[i];
1811
        if (keycode & 0x80)
1812
            kbd_put_keycode(0xe0);
1813
        kbd_put_keycode(keycode & 0x7f);
1814
    }
1815
    /* delayed key up events */
1816
    qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
1817
                   muldiv64(get_ticks_per_sec(), hold_time, 1000));
1818
}
1819

    
1820
static int mouse_button_state;
1821

    
1822
static void do_mouse_move(Monitor *mon, const QDict *qdict)
1823
{
1824
    int dx, dy, dz;
1825
    const char *dx_str = qdict_get_str(qdict, "dx_str");
1826
    const char *dy_str = qdict_get_str(qdict, "dy_str");
1827
    const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1828
    dx = strtol(dx_str, NULL, 0);
1829
    dy = strtol(dy_str, NULL, 0);
1830
    dz = 0;
1831
    if (dz_str)
1832
        dz = strtol(dz_str, NULL, 0);
1833
    kbd_mouse_event(dx, dy, dz, mouse_button_state);
1834
}
1835

    
1836
static void do_mouse_button(Monitor *mon, const QDict *qdict)
1837
{
1838
    int button_state = qdict_get_int(qdict, "button_state");
1839
    mouse_button_state = button_state;
1840
    kbd_mouse_event(0, 0, 0, mouse_button_state);
1841
}
1842

    
1843
static void do_ioport_read(Monitor *mon, const QDict *qdict)
1844
{
1845
    int size = qdict_get_int(qdict, "size");
1846
    int addr = qdict_get_int(qdict, "addr");
1847
    int has_index = qdict_haskey(qdict, "index");
1848
    uint32_t val;
1849
    int suffix;
1850

    
1851
    if (has_index) {
1852
        int index = qdict_get_int(qdict, "index");
1853
        cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1854
        addr++;
1855
    }
1856
    addr &= 0xffff;
1857

    
1858
    switch(size) {
1859
    default:
1860
    case 1:
1861
        val = cpu_inb(addr);
1862
        suffix = 'b';
1863
        break;
1864
    case 2:
1865
        val = cpu_inw(addr);
1866
        suffix = 'w';
1867
        break;
1868
    case 4:
1869
        val = cpu_inl(addr);
1870
        suffix = 'l';
1871
        break;
1872
    }
1873
    monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1874
                   suffix, addr, size * 2, val);
1875
}
1876

    
1877
static void do_ioport_write(Monitor *mon, const QDict *qdict)
1878
{
1879
    int size = qdict_get_int(qdict, "size");
1880
    int addr = qdict_get_int(qdict, "addr");
1881
    int val = qdict_get_int(qdict, "val");
1882

    
1883
    addr &= IOPORTS_MASK;
1884

    
1885
    switch (size) {
1886
    default:
1887
    case 1:
1888
        cpu_outb(addr, val);
1889
        break;
1890
    case 2:
1891
        cpu_outw(addr, val);
1892
        break;
1893
    case 4:
1894
        cpu_outl(addr, val);
1895
        break;
1896
    }
1897
}
1898

    
1899
static void do_boot_set(Monitor *mon, const QDict *qdict)
1900
{
1901
    int res;
1902
    const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1903

    
1904
    res = qemu_boot_set(bootdevice);
1905
    if (res == 0) {
1906
        monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1907
    } else if (res > 0) {
1908
        monitor_printf(mon, "setting boot device list failed\n");
1909
    } else {
1910
        monitor_printf(mon, "no function defined to set boot device list for "
1911
                       "this architecture\n");
1912
    }
1913
}
1914

    
1915
/**
1916
 * do_system_reset(): Issue a machine reset
1917
 */
1918
static int do_system_reset(Monitor *mon, const QDict *qdict,
1919
                           QObject **ret_data)
1920
{
1921
    qemu_system_reset_request();
1922
    return 0;
1923
}
1924

    
1925
/**
1926
 * do_system_powerdown(): Issue a machine powerdown
1927
 */
1928
static int do_system_powerdown(Monitor *mon, const QDict *qdict,
1929
                               QObject **ret_data)
1930
{
1931
    qemu_system_powerdown_request();
1932
    return 0;
1933
}
1934

    
1935
#if defined(TARGET_I386)
1936
static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
1937
{
1938
    monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
1939
                   addr,
1940
                   pte & mask,
1941
                   pte & PG_GLOBAL_MASK ? 'G' : '-',
1942
                   pte & PG_PSE_MASK ? 'P' : '-',
1943
                   pte & PG_DIRTY_MASK ? 'D' : '-',
1944
                   pte & PG_ACCESSED_MASK ? 'A' : '-',
1945
                   pte & PG_PCD_MASK ? 'C' : '-',
1946
                   pte & PG_PWT_MASK ? 'T' : '-',
1947
                   pte & PG_USER_MASK ? 'U' : '-',
1948
                   pte & PG_RW_MASK ? 'W' : '-');
1949
}
1950

    
1951
static void tlb_info(Monitor *mon)
1952
{
1953
    CPUState *env;
1954
    int l1, l2;
1955
    uint32_t pgd, pde, pte;
1956

    
1957
    env = mon_get_cpu();
1958

    
1959
    if (!(env->cr[0] & CR0_PG_MASK)) {
1960
        monitor_printf(mon, "PG disabled\n");
1961
        return;
1962
    }
1963
    pgd = env->cr[3] & ~0xfff;
1964
    for(l1 = 0; l1 < 1024; l1++) {
1965
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1966
        pde = le32_to_cpu(pde);
1967
        if (pde & PG_PRESENT_MASK) {
1968
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1969
                print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
1970
            } else {
1971
                for(l2 = 0; l2 < 1024; l2++) {
1972
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1973
                                             (uint8_t *)&pte, 4);
1974
                    pte = le32_to_cpu(pte);
1975
                    if (pte & PG_PRESENT_MASK) {
1976
                        print_pte(mon, (l1 << 22) + (l2 << 12),
1977
                                  pte & ~PG_PSE_MASK,
1978
                                  ~0xfff);
1979
                    }
1980
                }
1981
            }
1982
        }
1983
    }
1984
}
1985

    
1986
static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
1987
                      uint32_t end, int prot)
1988
{
1989
    int prot1;
1990
    prot1 = *plast_prot;
1991
    if (prot != prot1) {
1992
        if (*pstart != -1) {
1993
            monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
1994
                           *pstart, end, end - *pstart,
1995
                           prot1 & PG_USER_MASK ? 'u' : '-',
1996
                           'r',
1997
                           prot1 & PG_RW_MASK ? 'w' : '-');
1998
        }
1999
        if (prot != 0)
2000
            *pstart = end;
2001
        else
2002
            *pstart = -1;
2003
        *plast_prot = prot;
2004
    }
2005
}
2006

    
2007
static void mem_info(Monitor *mon)
2008
{
2009
    CPUState *env;
2010
    int l1, l2, prot, last_prot;
2011
    uint32_t pgd, pde, pte, start, end;
2012

    
2013
    env = mon_get_cpu();
2014

    
2015
    if (!(env->cr[0] & CR0_PG_MASK)) {
2016
        monitor_printf(mon, "PG disabled\n");
2017
        return;
2018
    }
2019
    pgd = env->cr[3] & ~0xfff;
2020
    last_prot = 0;
2021
    start = -1;
2022
    for(l1 = 0; l1 < 1024; l1++) {
2023
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
2024
        pde = le32_to_cpu(pde);
2025
        end = l1 << 22;
2026
        if (pde & PG_PRESENT_MASK) {
2027
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
2028
                prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
2029
                mem_print(mon, &start, &last_prot, end, prot);
2030
            } else {
2031
                for(l2 = 0; l2 < 1024; l2++) {
2032
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
2033
                                             (uint8_t *)&pte, 4);
2034
                    pte = le32_to_cpu(pte);
2035
                    end = (l1 << 22) + (l2 << 12);
2036
                    if (pte & PG_PRESENT_MASK) {
2037
                        prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
2038
                    } else {
2039
                        prot = 0;
2040
                    }
2041
                    mem_print(mon, &start, &last_prot, end, prot);
2042
                }
2043
            }
2044
        } else {
2045
            prot = 0;
2046
            mem_print(mon, &start, &last_prot, end, prot);
2047
        }
2048
    }
2049
}
2050
#endif
2051

    
2052
#if defined(TARGET_SH4)
2053

    
2054
static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
2055
{
2056
    monitor_printf(mon, " tlb%i:\t"
2057
                   "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
2058
                   "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
2059
                   "dirty=%hhu writethrough=%hhu\n",
2060
                   idx,
2061
                   tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
2062
                   tlb->v, tlb->sh, tlb->c, tlb->pr,
2063
                   tlb->d, tlb->wt);
2064
}
2065

    
2066
static void tlb_info(Monitor *mon)
2067
{
2068
    CPUState *env = mon_get_cpu();
2069
    int i;
2070

    
2071
    monitor_printf (mon, "ITLB:\n");
2072
    for (i = 0 ; i < ITLB_SIZE ; i++)
2073
        print_tlb (mon, i, &env->itlb[i]);
2074
    monitor_printf (mon, "UTLB:\n");
2075
    for (i = 0 ; i < UTLB_SIZE ; i++)
2076
        print_tlb (mon, i, &env->utlb[i]);
2077
}
2078

    
2079
#endif
2080

    
2081
static void do_info_kvm_print(Monitor *mon, const QObject *data)
2082
{
2083
    QDict *qdict;
2084

    
2085
    qdict = qobject_to_qdict(data);
2086

    
2087
    monitor_printf(mon, "kvm support: ");
2088
    if (qdict_get_bool(qdict, "present")) {
2089
        monitor_printf(mon, "%s\n", qdict_get_bool(qdict, "enabled") ?
2090
                                    "enabled" : "disabled");
2091
    } else {
2092
        monitor_printf(mon, "not compiled\n");
2093
    }
2094
}
2095

    
2096
/**
2097
 * do_info_kvm(): Show KVM information
2098
 *
2099
 * Return a QDict with the following information:
2100
 *
2101
 * - "enabled": true if KVM support is enabled, false otherwise
2102
 * - "present": true if QEMU has KVM support, false otherwise
2103
 *
2104
 * Example:
2105
 *
2106
 * { "enabled": true, "present": true }
2107
 */
2108
static void do_info_kvm(Monitor *mon, QObject **ret_data)
2109
{
2110
#ifdef CONFIG_KVM
2111
    *ret_data = qobject_from_jsonf("{ 'enabled': %i, 'present': true }",
2112
                                   kvm_enabled());
2113
#else
2114
    *ret_data = qobject_from_jsonf("{ 'enabled': false, 'present': false }");
2115
#endif
2116
}
2117

    
2118
static void do_info_numa(Monitor *mon)
2119
{
2120
    int i;
2121
    CPUState *env;
2122

    
2123
    monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
2124
    for (i = 0; i < nb_numa_nodes; i++) {
2125
        monitor_printf(mon, "node %d cpus:", i);
2126
        for (env = first_cpu; env != NULL; env = env->next_cpu) {
2127
            if (env->numa_node == i) {
2128
                monitor_printf(mon, " %d", env->cpu_index);
2129
            }
2130
        }
2131
        monitor_printf(mon, "\n");
2132
        monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2133
            node_mem[i] >> 20);
2134
    }
2135
}
2136

    
2137
#ifdef CONFIG_PROFILER
2138

    
2139
int64_t qemu_time;
2140
int64_t dev_time;
2141

    
2142
static void do_info_profile(Monitor *mon)
2143
{
2144
    int64_t total;
2145
    total = qemu_time;
2146
    if (total == 0)
2147
        total = 1;
2148
    monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
2149
                   dev_time, dev_time / (double)get_ticks_per_sec());
2150
    monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
2151
                   qemu_time, qemu_time / (double)get_ticks_per_sec());
2152
    qemu_time = 0;
2153
    dev_time = 0;
2154
}
2155
#else
2156
static void do_info_profile(Monitor *mon)
2157
{
2158
    monitor_printf(mon, "Internal profiler not compiled\n");
2159
}
2160
#endif
2161

    
2162
/* Capture support */
2163
static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2164

    
2165
static void do_info_capture(Monitor *mon)
2166
{
2167
    int i;
2168
    CaptureState *s;
2169

    
2170
    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2171
        monitor_printf(mon, "[%d]: ", i);
2172
        s->ops.info (s->opaque);
2173
    }
2174
}
2175

    
2176
#ifdef HAS_AUDIO
2177
static void do_stop_capture(Monitor *mon, const QDict *qdict)
2178
{
2179
    int i;
2180
    int n = qdict_get_int(qdict, "n");
2181
    CaptureState *s;
2182

    
2183
    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2184
        if (i == n) {
2185
            s->ops.destroy (s->opaque);
2186
            QLIST_REMOVE (s, entries);
2187
            qemu_free (s);
2188
            return;
2189
        }
2190
    }
2191
}
2192

    
2193
static void do_wav_capture(Monitor *mon, const QDict *qdict)
2194
{
2195
    const char *path = qdict_get_str(qdict, "path");
2196
    int has_freq = qdict_haskey(qdict, "freq");
2197
    int freq = qdict_get_try_int(qdict, "freq", -1);
2198
    int has_bits = qdict_haskey(qdict, "bits");
2199
    int bits = qdict_get_try_int(qdict, "bits", -1);
2200
    int has_channels = qdict_haskey(qdict, "nchannels");
2201
    int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2202
    CaptureState *s;
2203

    
2204
    s = qemu_mallocz (sizeof (*s));
2205

    
2206
    freq = has_freq ? freq : 44100;
2207
    bits = has_bits ? bits : 16;
2208
    nchannels = has_channels ? nchannels : 2;
2209

    
2210
    if (wav_start_capture (s, path, freq, bits, nchannels)) {
2211
        monitor_printf(mon, "Faied to add wave capture\n");
2212
        qemu_free (s);
2213
    }
2214
    QLIST_INSERT_HEAD (&capture_head, s, entries);
2215
}
2216
#endif
2217

    
2218
#if defined(TARGET_I386)
2219
static void do_inject_nmi(Monitor *mon, const QDict *qdict)
2220
{
2221
    CPUState *env;
2222
    int cpu_index = qdict_get_int(qdict, "cpu_index");
2223

    
2224
    for (env = first_cpu; env != NULL; env = env->next_cpu)
2225
        if (env->cpu_index == cpu_index) {
2226
            cpu_interrupt(env, CPU_INTERRUPT_NMI);
2227
            break;
2228
        }
2229
}
2230
#endif
2231

    
2232
static void do_info_status_print(Monitor *mon, const QObject *data)
2233
{
2234
    QDict *qdict;
2235

    
2236
    qdict = qobject_to_qdict(data);
2237

    
2238
    monitor_printf(mon, "VM status: ");
2239
    if (qdict_get_bool(qdict, "running")) {
2240
        monitor_printf(mon, "running");
2241
        if (qdict_get_bool(qdict, "singlestep")) {
2242
            monitor_printf(mon, " (single step mode)");
2243
        }
2244
    } else {
2245
        monitor_printf(mon, "paused");
2246
    }
2247

    
2248
    monitor_printf(mon, "\n");
2249
}
2250

    
2251
/**
2252
 * do_info_status(): VM status
2253
 *
2254
 * Return a QDict with the following information:
2255
 *
2256
 * - "running": true if the VM is running, or false if it is paused
2257
 * - "singlestep": true if the VM is in single step mode, false otherwise
2258
 *
2259
 * Example:
2260
 *
2261
 * { "running": true, "singlestep": false }
2262
 */
2263
static void do_info_status(Monitor *mon, QObject **ret_data)
2264
{
2265
    *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
2266
                                    vm_running, singlestep);
2267
}
2268

    
2269
static qemu_acl *find_acl(Monitor *mon, const char *name)
2270
{
2271
    qemu_acl *acl = qemu_acl_find(name);
2272

    
2273
    if (!acl) {
2274
        monitor_printf(mon, "acl: unknown list '%s'\n", name);
2275
    }
2276
    return acl;
2277
}
2278

    
2279
static void do_acl_show(Monitor *mon, const QDict *qdict)
2280
{
2281
    const char *aclname = qdict_get_str(qdict, "aclname");
2282
    qemu_acl *acl = find_acl(mon, aclname);
2283
    qemu_acl_entry *entry;
2284
    int i = 0;
2285

    
2286
    if (acl) {
2287
        monitor_printf(mon, "policy: %s\n",
2288
                       acl->defaultDeny ? "deny" : "allow");
2289
        QTAILQ_FOREACH(entry, &acl->entries, next) {
2290
            i++;
2291
            monitor_printf(mon, "%d: %s %s\n", i,
2292
                           entry->deny ? "deny" : "allow", entry->match);
2293
        }
2294
    }
2295
}
2296

    
2297
static void do_acl_reset(Monitor *mon, const QDict *qdict)
2298
{
2299
    const char *aclname = qdict_get_str(qdict, "aclname");
2300
    qemu_acl *acl = find_acl(mon, aclname);
2301

    
2302
    if (acl) {
2303
        qemu_acl_reset(acl);
2304
        monitor_printf(mon, "acl: removed all rules\n");
2305
    }
2306
}
2307

    
2308
static void do_acl_policy(Monitor *mon, const QDict *qdict)
2309
{
2310
    const char *aclname = qdict_get_str(qdict, "aclname");
2311
    const char *policy = qdict_get_str(qdict, "policy");
2312
    qemu_acl *acl = find_acl(mon, aclname);
2313

    
2314
    if (acl) {
2315
        if (strcmp(policy, "allow") == 0) {
2316
            acl->defaultDeny = 0;
2317
            monitor_printf(mon, "acl: policy set to 'allow'\n");
2318
        } else if (strcmp(policy, "deny") == 0) {
2319
            acl->defaultDeny = 1;
2320
            monitor_printf(mon, "acl: policy set to 'deny'\n");
2321
        } else {
2322
            monitor_printf(mon, "acl: unknown policy '%s', "
2323
                           "expected 'deny' or 'allow'\n", policy);
2324
        }
2325
    }
2326
}
2327

    
2328
static void do_acl_add(Monitor *mon, const QDict *qdict)
2329
{
2330
    const char *aclname = qdict_get_str(qdict, "aclname");
2331
    const char *match = qdict_get_str(qdict, "match");
2332
    const char *policy = qdict_get_str(qdict, "policy");
2333
    int has_index = qdict_haskey(qdict, "index");
2334
    int index = qdict_get_try_int(qdict, "index", -1);
2335
    qemu_acl *acl = find_acl(mon, aclname);
2336
    int deny, ret;
2337

    
2338
    if (acl) {
2339
        if (strcmp(policy, "allow") == 0) {
2340
            deny = 0;
2341
        } else if (strcmp(policy, "deny") == 0) {
2342
            deny = 1;
2343
        } else {
2344
            monitor_printf(mon, "acl: unknown policy '%s', "
2345
                           "expected 'deny' or 'allow'\n", policy);
2346
            return;
2347
        }
2348
        if (has_index)
2349
            ret = qemu_acl_insert(acl, deny, match, index);
2350
        else
2351
            ret = qemu_acl_append(acl, deny, match);
2352
        if (ret < 0)
2353
            monitor_printf(mon, "acl: unable to add acl entry\n");
2354
        else
2355
            monitor_printf(mon, "acl: added rule at position %d\n", ret);
2356
    }
2357
}
2358

    
2359
static void do_acl_remove(Monitor *mon, const QDict *qdict)
2360
{
2361
    const char *aclname = qdict_get_str(qdict, "aclname");
2362
    const char *match = qdict_get_str(qdict, "match");
2363
    qemu_acl *acl = find_acl(mon, aclname);
2364
    int ret;
2365

    
2366
    if (acl) {
2367
        ret = qemu_acl_remove(acl, match);
2368
        if (ret < 0)
2369
            monitor_printf(mon, "acl: no matching acl entry\n");
2370
        else
2371
            monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2372
    }
2373
}
2374

    
2375
#if defined(TARGET_I386)
2376
static void do_inject_mce(Monitor *mon, const QDict *qdict)
2377
{
2378
    CPUState *cenv;
2379
    int cpu_index = qdict_get_int(qdict, "cpu_index");
2380
    int bank = qdict_get_int(qdict, "bank");
2381
    uint64_t status = qdict_get_int(qdict, "status");
2382
    uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2383
    uint64_t addr = qdict_get_int(qdict, "addr");
2384
    uint64_t misc = qdict_get_int(qdict, "misc");
2385

    
2386
    for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
2387
        if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
2388
            cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
2389
            break;
2390
        }
2391
}
2392
#endif
2393

    
2394
static int do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2395
{
2396
    const char *fdname = qdict_get_str(qdict, "fdname");
2397
    mon_fd_t *monfd;
2398
    int fd;
2399

    
2400
    fd = qemu_chr_get_msgfd(mon->chr);
2401
    if (fd == -1) {
2402
        qerror_report(QERR_FD_NOT_SUPPLIED);
2403
        return -1;
2404
    }
2405

    
2406
    if (qemu_isdigit(fdname[0])) {
2407
        qerror_report(QERR_INVALID_PARAMETER, "fdname");
2408
        return -1;
2409
    }
2410

    
2411
    fd = dup(fd);
2412
    if (fd == -1) {
2413
        if (errno == EMFILE)
2414
            qerror_report(QERR_TOO_MANY_FILES);
2415
        else
2416
            qerror_report(QERR_UNDEFINED_ERROR);
2417
        return -1;
2418
    }
2419

    
2420
    QLIST_FOREACH(monfd, &mon->fds, next) {
2421
        if (strcmp(monfd->name, fdname) != 0) {
2422
            continue;
2423
        }
2424

    
2425
        close(monfd->fd);
2426
        monfd->fd = fd;
2427
        return 0;
2428
    }
2429

    
2430
    monfd = qemu_mallocz(sizeof(mon_fd_t));
2431
    monfd->name = qemu_strdup(fdname);
2432
    monfd->fd = fd;
2433

    
2434
    QLIST_INSERT_HEAD(&mon->fds, monfd, next);
2435
    return 0;
2436
}
2437

    
2438
static int do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2439
{
2440
    const char *fdname = qdict_get_str(qdict, "fdname");
2441
    mon_fd_t *monfd;
2442

    
2443
    QLIST_FOREACH(monfd, &mon->fds, next) {
2444
        if (strcmp(monfd->name, fdname) != 0) {
2445
            continue;
2446
        }
2447

    
2448
        QLIST_REMOVE(monfd, next);
2449
        close(monfd->fd);
2450
        qemu_free(monfd->name);
2451
        qemu_free(monfd);
2452
        return 0;
2453
    }
2454

    
2455
    qerror_report(QERR_FD_NOT_FOUND, fdname);
2456
    return -1;
2457
}
2458

    
2459
static void do_loadvm(Monitor *mon, const QDict *qdict)
2460
{
2461
    int saved_vm_running  = vm_running;
2462
    const char *name = qdict_get_str(qdict, "name");
2463

    
2464
    vm_stop(0);
2465

    
2466
    if (load_vmstate(name) >= 0 && saved_vm_running)
2467
        vm_start();
2468
}
2469

    
2470
int monitor_get_fd(Monitor *mon, const char *fdname)
2471
{
2472
    mon_fd_t *monfd;
2473

    
2474
    QLIST_FOREACH(monfd, &mon->fds, next) {
2475
        int fd;
2476

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

    
2481
        fd = monfd->fd;
2482

    
2483
        /* caller takes ownership of fd */
2484
        QLIST_REMOVE(monfd, next);
2485
        qemu_free(monfd->name);
2486
        qemu_free(monfd);
2487

    
2488
        return fd;
2489
    }
2490

    
2491
    return -1;
2492
}
2493

    
2494
static const mon_cmd_t mon_cmds[] = {
2495
#include "qemu-monitor.h"
2496
    { NULL, NULL, },
2497
};
2498

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

    
2783
/*******************************************************************/
2784

    
2785
static const char *pch;
2786
static jmp_buf expr_env;
2787

    
2788
#define MD_TLONG 0
2789
#define MD_I32   1
2790

    
2791
typedef struct MonitorDef {
2792
    const char *name;
2793
    int offset;
2794
    target_long (*get_value)(const struct MonitorDef *md, int val);
2795
    int type;
2796
} MonitorDef;
2797

    
2798
#if defined(TARGET_I386)
2799
static target_long monitor_get_pc (const struct MonitorDef *md, int val)
2800
{
2801
    CPUState *env = mon_get_cpu();
2802
    return env->eip + env->segs[R_CS].base;
2803
}
2804
#endif
2805

    
2806
#if defined(TARGET_PPC)
2807
static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
2808
{
2809
    CPUState *env = mon_get_cpu();
2810
    unsigned int u;
2811
    int i;
2812

    
2813
    u = 0;
2814
    for (i = 0; i < 8; i++)
2815
        u |= env->crf[i] << (32 - (4 * i));
2816

    
2817
    return u;
2818
}
2819

    
2820
static target_long monitor_get_msr (const struct MonitorDef *md, int val)
2821
{
2822
    CPUState *env = mon_get_cpu();
2823
    return env->msr;
2824
}
2825

    
2826
static target_long monitor_get_xer (const struct MonitorDef *md, int val)
2827
{
2828
    CPUState *env = mon_get_cpu();
2829
    return env->xer;
2830
}
2831

    
2832
static target_long monitor_get_decr (const struct MonitorDef *md, int val)
2833
{
2834
    CPUState *env = mon_get_cpu();
2835
    return cpu_ppc_load_decr(env);
2836
}
2837

    
2838
static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
2839
{
2840
    CPUState *env = mon_get_cpu();
2841
    return cpu_ppc_load_tbu(env);
2842
}
2843

    
2844
static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
2845
{
2846
    CPUState *env = mon_get_cpu();
2847
    return cpu_ppc_load_tbl(env);
2848
}
2849
#endif
2850

    
2851
#if defined(TARGET_SPARC)
2852
#ifndef TARGET_SPARC64
2853
static target_long monitor_get_psr (const struct MonitorDef *md, int val)
2854
{
2855
    CPUState *env = mon_get_cpu();
2856
    return GET_PSR(env);
2857
}
2858
#endif
2859

    
2860
static target_long monitor_get_reg(const struct MonitorDef *md, int val)
2861
{
2862
    CPUState *env = mon_get_cpu();
2863
    return env->regwptr[val];
2864
}
2865
#endif
2866

    
2867
static const MonitorDef monitor_defs[] = {
2868
#ifdef TARGET_I386
2869

    
2870
#define SEG(name, seg) \
2871
    { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
2872
    { name ".base", offsetof(CPUState, segs[seg].base) },\
2873
    { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
2874

    
2875
    { "eax", offsetof(CPUState, regs[0]) },
2876
    { "ecx", offsetof(CPUState, regs[1]) },
2877
    { "edx", offsetof(CPUState, regs[2]) },
2878
    { "ebx", offsetof(CPUState, regs[3]) },
2879
    { "esp|sp", offsetof(CPUState, regs[4]) },
2880
    { "ebp|fp", offsetof(CPUState, regs[5]) },
2881
    { "esi", offsetof(CPUState, regs[6]) },
2882
    { "edi", offsetof(CPUState, regs[7]) },
2883
#ifdef TARGET_X86_64
2884
    { "r8", offsetof(CPUState, regs[8]) },
2885
    { "r9", offsetof(CPUState, regs[9]) },
2886
    { "r10", offsetof(CPUState, regs[10]) },
2887
    { "r11", offsetof(CPUState, regs[11]) },
2888
    { "r12", offsetof(CPUState, regs[12]) },
2889
    { "r13", offsetof(CPUState, regs[13]) },
2890
    { "r14", offsetof(CPUState, regs[14]) },
2891
    { "r15", offsetof(CPUState, regs[15]) },
2892
#endif
2893
    { "eflags", offsetof(CPUState, eflags) },
2894
    { "eip", offsetof(CPUState, eip) },
2895
    SEG("cs", R_CS)
2896
    SEG("ds", R_DS)
2897
    SEG("es", R_ES)
2898
    SEG("ss", R_SS)
2899
    SEG("fs", R_FS)
2900
    SEG("gs", R_GS)
2901
    { "pc", 0, monitor_get_pc, },
2902
#elif defined(TARGET_PPC)
2903
    /* General purpose registers */
2904
    { "r0", offsetof(CPUState, gpr[0]) },
2905
    { "r1", offsetof(CPUState, gpr[1]) },
2906
    { "r2", offsetof(CPUState, gpr[2]) },
2907
    { "r3", offsetof(CPUState, gpr[3]) },
2908
    { "r4", offsetof(CPUState, gpr[4]) },
2909
    { "r5", offsetof(CPUState, gpr[5]) },
2910
    { "r6", offsetof(CPUState, gpr[6]) },
2911
    { "r7", offsetof(CPUState, gpr[7]) },
2912
    { "r8", offsetof(CPUState, gpr[8]) },
2913
    { "r9", offsetof(CPUState, gpr[9]) },
2914
    { "r10", offsetof(CPUState, gpr[10]) },
2915
    { "r11", offsetof(CPUState, gpr[11]) },
2916
    { "r12", offsetof(CPUState, gpr[12]) },
2917
    { "r13", offsetof(CPUState, gpr[13]) },
2918
    { "r14", offsetof(CPUState, gpr[14]) },
2919
    { "r15", offsetof(CPUState, gpr[15]) },
2920
    { "r16", offsetof(CPUState, gpr[16]) },
2921
    { "r17", offsetof(CPUState, gpr[17]) },
2922
    { "r18", offsetof(CPUState, gpr[18]) },
2923
    { "r19", offsetof(CPUState, gpr[19]) },
2924
    { "r20", offsetof(CPUState, gpr[20]) },
2925
    { "r21", offsetof(CPUState, gpr[21]) },
2926
    { "r22", offsetof(CPUState, gpr[22]) },
2927
    { "r23", offsetof(CPUState, gpr[23]) },
2928
    { "r24", offsetof(CPUState, gpr[24]) },
2929
    { "r25", offsetof(CPUState, gpr[25]) },
2930
    { "r26", offsetof(CPUState, gpr[26]) },
2931
    { "r27", offsetof(CPUState, gpr[27]) },
2932
    { "r28", offsetof(CPUState, gpr[28]) },
2933
    { "r29", offsetof(CPUState, gpr[29]) },
2934
    { "r30", offsetof(CPUState, gpr[30]) },
2935
    { "r31", offsetof(CPUState, gpr[31]) },
2936
    /* Floating point registers */
2937
    { "f0", offsetof(CPUState, fpr[0]) },
2938
    { "f1", offsetof(CPUState, fpr[1]) },
2939
    { "f2", offsetof(CPUState, fpr[2]) },
2940
    { "f3", offsetof(CPUState, fpr[3]) },
2941
    { "f4", offsetof(CPUState, fpr[4]) },
2942
    { "f5", offsetof(CPUState, fpr[5]) },
2943
    { "f6", offsetof(CPUState, fpr[6]) },
2944
    { "f7", offsetof(CPUState, fpr[7]) },
2945
    { "f8", offsetof(CPUState, fpr[8]) },
2946
    { "f9", offsetof(CPUState, fpr[9]) },
2947
    { "f10", offsetof(CPUState, fpr[10]) },
2948
    { "f11", offsetof(CPUState, fpr[11]) },
2949
    { "f12", offsetof(CPUState, fpr[12]) },
2950
    { "f13", offsetof(CPUState, fpr[13]) },
2951
    { "f14", offsetof(CPUState, fpr[14]) },
2952
    { "f15", offsetof(CPUState, fpr[15]) },
2953
    { "f16", offsetof(CPUState, fpr[16]) },
2954
    { "f17", offsetof(CPUState, fpr[17]) },
2955
    { "f18", offsetof(CPUState, fpr[18]) },
2956
    { "f19", offsetof(CPUState, fpr[19]) },
2957
    { "f20", offsetof(CPUState, fpr[20]) },
2958
    { "f21", offsetof(CPUState, fpr[21]) },
2959
    { "f22", offsetof(CPUState, fpr[22]) },
2960
    { "f23", offsetof(CPUState, fpr[23]) },
2961
    { "f24", offsetof(CPUState, fpr[24]) },
2962
    { "f25", offsetof(CPUState, fpr[25]) },
2963
    { "f26", offsetof(CPUState, fpr[26]) },
2964
    { "f27", offsetof(CPUState, fpr[27]) },
2965
    { "f28", offsetof(CPUState, fpr[28]) },
2966
    { "f29", offsetof(CPUState, fpr[29]) },
2967
    { "f30", offsetof(CPUState, fpr[30]) },
2968
    { "f31", offsetof(CPUState, fpr[31]) },
2969
    { "fpscr", offsetof(CPUState, fpscr) },
2970
    /* Next instruction pointer */
2971
    { "nip|pc", offsetof(CPUState, nip) },
2972
    { "lr", offsetof(CPUState, lr) },
2973
    { "ctr", offsetof(CPUState, ctr) },
2974
    { "decr", 0, &monitor_get_decr, },
2975
    { "ccr", 0, &monitor_get_ccr, },
2976
    /* Machine state register */
2977
    { "msr", 0, &monitor_get_msr, },
2978
    { "xer", 0, &monitor_get_xer, },
2979
    { "tbu", 0, &monitor_get_tbu, },
2980
    { "tbl", 0, &monitor_get_tbl, },
2981
#if defined(TARGET_PPC64)
2982
    /* Address space register */
2983
    { "asr", offsetof(CPUState, asr) },
2984
#endif
2985
    /* Segment registers */
2986
    { "sdr1", offsetof(CPUState, sdr1) },
2987
    { "sr0", offsetof(CPUState, sr[0]) },
2988
    { "sr1", offsetof(CPUState, sr[1]) },
2989
    { "sr2", offsetof(CPUState, sr[2]) },
2990
    { "sr3", offsetof(CPUState, sr[3]) },
2991
    { "sr4", offsetof(CPUState, sr[4]) },
2992
    { "sr5", offsetof(CPUState, sr[5]) },
2993
    { "sr6", offsetof(CPUState, sr[6]) },
2994
    { "sr7", offsetof(CPUState, sr[7]) },
2995
    { "sr8", offsetof(CPUState, sr[8]) },
2996
    { "sr9", offsetof(CPUState, sr[9]) },
2997
    { "sr10", offsetof(CPUState, sr[10]) },
2998
    { "sr11", offsetof(CPUState, sr[11]) },
2999
    { "sr12", offsetof(CPUState, sr[12]) },
3000
    { "sr13", offsetof(CPUState, sr[13]) },
3001
    { "sr14", offsetof(CPUState, sr[14]) },
3002
    { "sr15", offsetof(CPUState, sr[15]) },
3003
    /* Too lazy to put BATs and SPRs ... */
3004
#elif defined(TARGET_SPARC)
3005
    { "g0", offsetof(CPUState, gregs[0]) },
3006
    { "g1", offsetof(CPUState, gregs[1]) },
3007
    { "g2", offsetof(CPUState, gregs[2]) },
3008
    { "g3", offsetof(CPUState, gregs[3]) },
3009
    { "g4", offsetof(CPUState, gregs[4]) },
3010
    { "g5", offsetof(CPUState, gregs[5]) },
3011
    { "g6", offsetof(CPUState, gregs[6]) },
3012
    { "g7", offsetof(CPUState, gregs[7]) },
3013
    { "o0", 0, monitor_get_reg },
3014
    { "o1", 1, monitor_get_reg },
3015
    { "o2", 2, monitor_get_reg },
3016
    { "o3", 3, monitor_get_reg },
3017
    { "o4", 4, monitor_get_reg },
3018
    { "o5", 5, monitor_get_reg },
3019
    { "o6", 6, monitor_get_reg },
3020
    { "o7", 7, monitor_get_reg },
3021
    { "l0", 8, monitor_get_reg },
3022
    { "l1", 9, monitor_get_reg },
3023
    { "l2", 10, monitor_get_reg },
3024
    { "l3", 11, monitor_get_reg },
3025
    { "l4", 12, monitor_get_reg },
3026
    { "l5", 13, monitor_get_reg },
3027
    { "l6", 14, monitor_get_reg },
3028
    { "l7", 15, monitor_get_reg },
3029
    { "i0", 16, monitor_get_reg },
3030
    { "i1", 17, monitor_get_reg },
3031
    { "i2", 18, monitor_get_reg },
3032
    { "i3", 19, monitor_get_reg },
3033
    { "i4", 20, monitor_get_reg },
3034
    { "i5", 21, monitor_get_reg },
3035
    { "i6", 22, monitor_get_reg },
3036
    { "i7", 23, monitor_get_reg },
3037
    { "pc", offsetof(CPUState, pc) },
3038
    { "npc", offsetof(CPUState, npc) },
3039
    { "y", offsetof(CPUState, y) },
3040
#ifndef TARGET_SPARC64
3041
    { "psr", 0, &monitor_get_psr, },
3042
    { "wim", offsetof(CPUState, wim) },
3043
#endif
3044
    { "tbr", offsetof(CPUState, tbr) },
3045
    { "fsr", offsetof(CPUState, fsr) },
3046
    { "f0", offsetof(CPUState, fpr[0]) },
3047
    { "f1", offsetof(CPUState, fpr[1]) },
3048
    { "f2", offsetof(CPUState, fpr[2]) },
3049
    { "f3", offsetof(CPUState, fpr[3]) },
3050
    { "f4", offsetof(CPUState, fpr[4]) },
3051
    { "f5", offsetof(CPUState, fpr[5]) },
3052
    { "f6", offsetof(CPUState, fpr[6]) },
3053
    { "f7", offsetof(CPUState, fpr[7]) },
3054
    { "f8", offsetof(CPUState, fpr[8]) },
3055
    { "f9", offsetof(CPUState, fpr[9]) },
3056
    { "f10", offsetof(CPUState, fpr[10]) },
3057
    { "f11", offsetof(CPUState, fpr[11]) },
3058
    { "f12", offsetof(CPUState, fpr[12]) },
3059
    { "f13", offsetof(CPUState, fpr[13]) },
3060
    { "f14", offsetof(CPUState, fpr[14]) },
3061
    { "f15", offsetof(CPUState, fpr[15]) },
3062
    { "f16", offsetof(CPUState, fpr[16]) },
3063
    { "f17", offsetof(CPUState, fpr[17]) },
3064
    { "f18", offsetof(CPUState, fpr[18]) },
3065
    { "f19", offsetof(CPUState, fpr[19]) },
3066
    { "f20", offsetof(CPUState, fpr[20]) },
3067
    { "f21", offsetof(CPUState, fpr[21]) },
3068
    { "f22", offsetof(CPUState, fpr[22]) },
3069
    { "f23", offsetof(CPUState, fpr[23]) },
3070
    { "f24", offsetof(CPUState, fpr[24]) },
3071
    { "f25", offsetof(CPUState, fpr[25]) },
3072
    { "f26", offsetof(CPUState, fpr[26]) },
3073
    { "f27", offsetof(CPUState, fpr[27]) },
3074
    { "f28", offsetof(CPUState, fpr[28]) },
3075
    { "f29", offsetof(CPUState, fpr[29]) },
3076
    { "f30", offsetof(CPUState, fpr[30]) },
3077
    { "f31", offsetof(CPUState, fpr[31]) },
3078
#ifdef TARGET_SPARC64
3079
    { "f32", offsetof(CPUState, fpr[32]) },
3080
    { "f34", offsetof(CPUState, fpr[34]) },
3081
    { "f36", offsetof(CPUState, fpr[36]) },
3082
    { "f38", offsetof(CPUState, fpr[38]) },
3083
    { "f40", offsetof(CPUState, fpr[40]) },
3084
    { "f42", offsetof(CPUState, fpr[42]) },
3085
    { "f44", offsetof(CPUState, fpr[44]) },
3086
    { "f46", offsetof(CPUState, fpr[46]) },
3087
    { "f48", offsetof(CPUState, fpr[48]) },
3088
    { "f50", offsetof(CPUState, fpr[50]) },
3089
    { "f52", offsetof(CPUState, fpr[52]) },
3090
    { "f54", offsetof(CPUState, fpr[54]) },
3091
    { "f56", offsetof(CPUState, fpr[56]) },
3092
    { "f58", offsetof(CPUState, fpr[58]) },
3093
    { "f60", offsetof(CPUState, fpr[60]) },
3094
    { "f62", offsetof(CPUState, fpr[62]) },
3095
    { "asi", offsetof(CPUState, asi) },
3096
    { "pstate", offsetof(CPUState, pstate) },
3097
    { "cansave", offsetof(CPUState, cansave) },
3098
    { "canrestore", offsetof(CPUState, canrestore) },
3099
    { "otherwin", offsetof(CPUState, otherwin) },
3100
    { "wstate", offsetof(CPUState, wstate) },
3101
    { "cleanwin", offsetof(CPUState, cleanwin) },
3102
    { "fprs", offsetof(CPUState, fprs) },
3103
#endif
3104
#endif
3105
    { NULL },
3106
};
3107

    
3108
static void expr_error(Monitor *mon, const char *msg)
3109
{
3110
    monitor_printf(mon, "%s\n", msg);
3111
    longjmp(expr_env, 1);
3112
}
3113

    
3114
/* return 0 if OK, -1 if not found */
3115
static int get_monitor_def(target_long *pval, const char *name)
3116
{
3117
    const MonitorDef *md;
3118
    void *ptr;
3119

    
3120
    for(md = monitor_defs; md->name != NULL; md++) {
3121
        if (compare_cmd(name, md->name)) {
3122
            if (md->get_value) {
3123
                *pval = md->get_value(md, md->offset);
3124
            } else {
3125
                CPUState *env = mon_get_cpu();
3126
                ptr = (uint8_t *)env + md->offset;
3127
                switch(md->type) {
3128
                case MD_I32:
3129
                    *pval = *(int32_t *)ptr;
3130
                    break;
3131
                case MD_TLONG:
3132
                    *pval = *(target_long *)ptr;
3133
                    break;
3134
                default:
3135
                    *pval = 0;
3136
                    break;
3137
                }
3138
            }
3139
            return 0;
3140
        }
3141
    }
3142
    return -1;
3143
}
3144

    
3145
static void next(void)
3146
{
3147
    if (*pch != '\0') {
3148
        pch++;
3149
        while (qemu_isspace(*pch))
3150
            pch++;
3151
    }
3152
}
3153

    
3154
static int64_t expr_sum(Monitor *mon);
3155

    
3156
static int64_t expr_unary(Monitor *mon)
3157
{
3158
    int64_t n;
3159
    char *p;
3160
    int ret;
3161

    
3162
    switch(*pch) {
3163
    case '+':
3164
        next();
3165
        n = expr_unary(mon);
3166
        break;
3167
    case '-':
3168
        next();
3169
        n = -expr_unary(mon);
3170
        break;
3171
    case '~':
3172
        next();
3173
        n = ~expr_unary(mon);
3174
        break;
3175
    case '(':
3176
        next();
3177
        n = expr_sum(mon);
3178
        if (*pch != ')') {
3179
            expr_error(mon, "')' expected");
3180
        }
3181
        next();
3182
        break;
3183
    case '\'':
3184
        pch++;
3185
        if (*pch == '\0')
3186
            expr_error(mon, "character constant expected");
3187
        n = *pch;
3188
        pch++;
3189
        if (*pch != '\'')
3190
            expr_error(mon, "missing terminating \' character");
3191
        next();
3192
        break;
3193
    case '$':
3194
        {
3195
            char buf[128], *q;
3196
            target_long reg=0;
3197

    
3198
            pch++;
3199
            q = buf;
3200
            while ((*pch >= 'a' && *pch <= 'z') ||
3201
                   (*pch >= 'A' && *pch <= 'Z') ||
3202
                   (*pch >= '0' && *pch <= '9') ||
3203
                   *pch == '_' || *pch == '.') {
3204
                if ((q - buf) < sizeof(buf) - 1)
3205
                    *q++ = *pch;
3206
                pch++;
3207
            }
3208
            while (qemu_isspace(*pch))
3209
                pch++;
3210
            *q = 0;
3211
            ret = get_monitor_def(&reg, buf);
3212
            if (ret < 0)
3213
                expr_error(mon, "unknown register");
3214
            n = reg;
3215
        }
3216
        break;
3217
    case '\0':
3218
        expr_error(mon, "unexpected end of expression");
3219
        n = 0;
3220
        break;
3221
    default:
3222
#if TARGET_PHYS_ADDR_BITS > 32
3223
        n = strtoull(pch, &p, 0);
3224
#else
3225
        n = strtoul(pch, &p, 0);
3226
#endif
3227
        if (pch == p) {
3228
            expr_error(mon, "invalid char in expression");
3229
        }
3230
        pch = p;
3231
        while (qemu_isspace(*pch))
3232
            pch++;
3233
        break;
3234
    }
3235
    return n;
3236
}
3237

    
3238

    
3239
static int64_t expr_prod(Monitor *mon)
3240
{
3241
    int64_t val, val2;
3242
    int op;
3243

    
3244
    val = expr_unary(mon);
3245
    for(;;) {
3246
        op = *pch;
3247
        if (op != '*' && op != '/' && op != '%')
3248
            break;
3249
        next();
3250
        val2 = expr_unary(mon);
3251
        switch(op) {
3252
        default:
3253
        case '*':
3254
            val *= val2;
3255
            break;
3256
        case '/':
3257
        case '%':
3258
            if (val2 == 0)
3259
                expr_error(mon, "division by zero");
3260
            if (op == '/')
3261
                val /= val2;
3262
            else
3263
                val %= val2;
3264
            break;
3265
        }
3266
    }
3267
    return val;
3268
}
3269

    
3270
static int64_t expr_logic(Monitor *mon)
3271
{
3272
    int64_t val, val2;
3273
    int op;
3274

    
3275
    val = expr_prod(mon);
3276
    for(;;) {
3277
        op = *pch;
3278
        if (op != '&' && op != '|' && op != '^')
3279
            break;
3280
        next();
3281
        val2 = expr_prod(mon);
3282
        switch(op) {
3283
        default:
3284
        case '&':
3285
            val &= val2;
3286
            break;
3287
        case '|':
3288
            val |= val2;
3289
            break;
3290
        case '^':
3291
            val ^= val2;
3292
            break;
3293
        }
3294
    }
3295
    return val;
3296
}
3297

    
3298
static int64_t expr_sum(Monitor *mon)
3299
{
3300
    int64_t val, val2;
3301
    int op;
3302

    
3303
    val = expr_logic(mon);
3304
    for(;;) {
3305
        op = *pch;
3306
        if (op != '+' && op != '-')
3307
            break;
3308
        next();
3309
        val2 = expr_logic(mon);
3310
        if (op == '+')
3311
            val += val2;
3312
        else
3313
            val -= val2;
3314
    }
3315
    return val;
3316
}
3317

    
3318
static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3319
{
3320
    pch = *pp;
3321
    if (setjmp(expr_env)) {
3322
        *pp = pch;
3323
        return -1;
3324
    }
3325
    while (qemu_isspace(*pch))
3326
        pch++;
3327
    *pval = expr_sum(mon);
3328
    *pp = pch;
3329
    return 0;
3330
}
3331

    
3332
static int get_double(Monitor *mon, double *pval, const char **pp)
3333
{
3334
    const char *p = *pp;
3335
    char *tailp;
3336
    double d;
3337

    
3338
    d = strtod(p, &tailp);
3339
    if (tailp == p) {
3340
        monitor_printf(mon, "Number expected\n");
3341
        return -1;
3342
    }
3343
    if (d != d || d - d != 0) {
3344
        /* NaN or infinity */
3345
        monitor_printf(mon, "Bad number\n");
3346
        return -1;
3347
    }
3348
    *pval = d;
3349
    *pp = tailp;
3350
    return 0;
3351
}
3352

    
3353
static int get_str(char *buf, int buf_size, const char **pp)
3354
{
3355
    const char *p;
3356
    char *q;
3357
    int c;
3358

    
3359
    q = buf;
3360
    p = *pp;
3361
    while (qemu_isspace(*p))
3362
        p++;
3363
    if (*p == '\0') {
3364
    fail:
3365
        *q = '\0';
3366
        *pp = p;
3367
        return -1;
3368
    }
3369
    if (*p == '\"') {
3370
        p++;
3371
        while (*p != '\0' && *p != '\"') {
3372
            if (*p == '\\') {
3373
                p++;
3374
                c = *p++;
3375
                switch(c) {
3376
                case 'n':
3377
                    c = '\n';
3378
                    break;
3379
                case 'r':
3380
                    c = '\r';
3381
                    break;
3382
                case '\\':
3383
                case '\'':
3384
                case '\"':
3385
                    break;
3386
                default:
3387
                    qemu_printf("unsupported escape code: '\\%c'\n", c);
3388
                    goto fail;
3389
                }
3390
                if ((q - buf) < buf_size - 1) {
3391
                    *q++ = c;
3392
                }
3393
            } else {
3394
                if ((q - buf) < buf_size - 1) {
3395
                    *q++ = *p;
3396
                }
3397
                p++;
3398
            }
3399
        }
3400
        if (*p != '\"') {
3401
            qemu_printf("unterminated string\n");
3402
            goto fail;
3403
        }
3404
        p++;
3405
    } else {
3406
        while (*p != '\0' && !qemu_isspace(*p)) {
3407
            if ((q - buf) < buf_size - 1) {
3408
                *q++ = *p;
3409
            }
3410
            p++;
3411
        }
3412
    }
3413
    *q = '\0';
3414
    *pp = p;
3415
    return 0;
3416
}
3417

    
3418
/*
3419
 * Store the command-name in cmdname, and return a pointer to
3420
 * the remaining of the command string.
3421
 */
3422
static const char *get_command_name(const char *cmdline,
3423
                                    char *cmdname, size_t nlen)
3424
{
3425
    size_t len;
3426
    const char *p, *pstart;
3427

    
3428
    p = cmdline;
3429
    while (qemu_isspace(*p))
3430
        p++;
3431
    if (*p == '\0')
3432
        return NULL;
3433
    pstart = p;
3434
    while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3435
        p++;
3436
    len = p - pstart;
3437
    if (len > nlen - 1)
3438
        len = nlen - 1;
3439
    memcpy(cmdname, pstart, len);
3440
    cmdname[len] = '\0';
3441
    return p;
3442
}
3443

    
3444
/**
3445
 * Read key of 'type' into 'key' and return the current
3446
 * 'type' pointer.
3447
 */
3448
static char *key_get_info(const char *type, char **key)
3449
{
3450
    size_t len;
3451
    char *p, *str;
3452

    
3453
    if (*type == ',')
3454
        type++;
3455

    
3456
    p = strchr(type, ':');
3457
    if (!p) {
3458
        *key = NULL;
3459
        return NULL;
3460
    }
3461
    len = p - type;
3462

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

    
3467
    *key = str;
3468
    return ++p;
3469
}
3470

    
3471
static int default_fmt_format = 'x';
3472
static int default_fmt_size = 4;
3473

    
3474
#define MAX_ARGS 16
3475

    
3476
static int is_valid_option(const char *c, const char *typestr)
3477
{
3478
    char option[3];
3479
  
3480
    option[0] = '-';
3481
    option[1] = *c;
3482
    option[2] = '\0';
3483
  
3484
    typestr = strstr(typestr, option);
3485
    return (typestr != NULL);
3486
}
3487

    
3488
static const mon_cmd_t *monitor_find_command(const char *cmdname)
3489
{
3490
    const mon_cmd_t *cmd;
3491

    
3492
    for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
3493
        if (compare_cmd(cmdname, cmd->name)) {
3494
            return cmd;
3495
        }
3496
    }
3497

    
3498
    return NULL;
3499
}
3500

    
3501
static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3502
                                              const char *cmdline,
3503
                                              QDict *qdict)
3504
{
3505
    const char *p, *typestr;
3506
    int c;
3507
    const mon_cmd_t *cmd;
3508
    char cmdname[256];
3509
    char buf[1024];
3510
    char *key;
3511

    
3512
#ifdef DEBUG
3513
    monitor_printf(mon, "command='%s'\n", cmdline);
3514
#endif
3515

    
3516
    /* extract the command name */
3517
    p = get_command_name(cmdline, cmdname, sizeof(cmdname));
3518
    if (!p)
3519
        return NULL;
3520

    
3521
    cmd = monitor_find_command(cmdname);
3522
    if (!cmd) {
3523
        monitor_printf(mon, "unknown command: '%s'\n", cmdname);
3524
        return NULL;
3525
    }
3526

    
3527
    /* parse the parameters */
3528
    typestr = cmd->args_type;
3529
    for(;;) {
3530
        typestr = key_get_info(typestr, &key);
3531
        if (!typestr)
3532
            break;
3533
        c = *typestr;
3534
        typestr++;
3535
        switch(c) {
3536
        case 'F':
3537
        case 'B':
3538
        case 's':
3539
            {
3540
                int ret;
3541

    
3542
                while (qemu_isspace(*p))
3543
                    p++;
3544
                if (*typestr == '?') {
3545
                    typestr++;
3546
                    if (*p == '\0') {
3547
                        /* no optional string: NULL argument */
3548
                        break;
3549
                    }
3550
                }
3551
                ret = get_str(buf, sizeof(buf), &p);
3552
                if (ret < 0) {
3553
                    switch(c) {
3554
                    case 'F':
3555
                        monitor_printf(mon, "%s: filename expected\n",
3556
                                       cmdname);
3557
                        break;
3558
                    case 'B':
3559
                        monitor_printf(mon, "%s: block device name expected\n",
3560
                                       cmdname);
3561
                        break;
3562
                    default:
3563
                        monitor_printf(mon, "%s: string expected\n", cmdname);
3564
                        break;
3565
                    }
3566
                    goto fail;
3567
                }
3568
                qdict_put(qdict, key, qstring_from_str(buf));
3569
            }
3570
            break;
3571
        case 'O':
3572
            {
3573
                QemuOptsList *opts_list;
3574
                QemuOpts *opts;
3575

    
3576
                opts_list = qemu_find_opts(key);
3577
                if (!opts_list || opts_list->desc->name) {
3578
                    goto bad_type;
3579
                }
3580
                while (qemu_isspace(*p)) {
3581
                    p++;
3582
                }
3583
                if (!*p)
3584
                    break;
3585
                if (get_str(buf, sizeof(buf), &p) < 0) {
3586
                    goto fail;
3587
                }
3588
                opts = qemu_opts_parse(opts_list, buf, 1);
3589
                if (!opts) {
3590
                    goto fail;
3591
                }
3592
                qemu_opts_to_qdict(opts, qdict);
3593
                qemu_opts_del(opts);
3594
            }
3595
            break;
3596
        case '/':
3597
            {
3598
                int count, format, size;
3599

    
3600
                while (qemu_isspace(*p))
3601
                    p++;
3602
                if (*p == '/') {
3603
                    /* format found */
3604
                    p++;
3605
                    count = 1;
3606
                    if (qemu_isdigit(*p)) {
3607
                        count = 0;
3608
                        while (qemu_isdigit(*p)) {
3609
                            count = count * 10 + (*p - '0');
3610
                            p++;
3611
                        }
3612
                    }
3613
                    size = -1;
3614
                    format = -1;
3615
                    for(;;) {
3616
                        switch(*p) {
3617
                        case 'o':
3618
                        case 'd':
3619
                        case 'u':
3620
                        case 'x':
3621
                        case 'i':
3622
                        case 'c':
3623
                            format = *p++;
3624
                            break;
3625
                        case 'b':
3626
                            size = 1;
3627
                            p++;
3628
                            break;
3629
                        case 'h':
3630
                            size = 2;
3631
                            p++;
3632
                            break;
3633
                        case 'w':
3634
                            size = 4;
3635
                            p++;
3636
                            break;
3637
                        case 'g':
3638
                        case 'L':
3639
                            size = 8;
3640
                            p++;
3641
                            break;
3642
                        default:
3643
                            goto next;
3644
                        }
3645
                    }
3646
                next:
3647
                    if (*p != '\0' && !qemu_isspace(*p)) {
3648
                        monitor_printf(mon, "invalid char in format: '%c'\n",
3649
                                       *p);
3650
                        goto fail;
3651
                    }
3652
                    if (format < 0)
3653
                        format = default_fmt_format;
3654
                    if (format != 'i') {
3655
                        /* for 'i', not specifying a size gives -1 as size */
3656
                        if (size < 0)
3657
                            size = default_fmt_size;
3658
                        default_fmt_size = size;
3659
                    }
3660
                    default_fmt_format = format;
3661
                } else {
3662
                    count = 1;
3663
                    format = default_fmt_format;
3664
                    if (format != 'i') {
3665
                        size = default_fmt_size;
3666
                    } else {
3667
                        size = -1;
3668
                    }
3669
                }
3670
                qdict_put(qdict, "count", qint_from_int(count));
3671
                qdict_put(qdict, "format", qint_from_int(format));
3672
                qdict_put(qdict, "size", qint_from_int(size));
3673
            }
3674
            break;
3675
        case 'i':
3676
        case 'l':
3677
        case 'M':
3678
            {
3679
                int64_t val;
3680

    
3681
                while (qemu_isspace(*p))
3682
                    p++;
3683
                if (*typestr == '?' || *typestr == '.') {
3684
                    if (*typestr == '?') {
3685
                        if (*p == '\0') {
3686
                            typestr++;
3687
                            break;
3688
                        }
3689
                    } else {
3690
                        if (*p == '.') {
3691
                            p++;
3692
                            while (qemu_isspace(*p))
3693
                                p++;
3694
                        } else {
3695
                            typestr++;
3696
                            break;
3697
                        }
3698
                    }
3699
                    typestr++;
3700
                }
3701
                if (get_expr(mon, &val, &p))
3702
                    goto fail;
3703
                /* Check if 'i' is greater than 32-bit */
3704
                if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3705
                    monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3706
                    monitor_printf(mon, "integer is for 32-bit values\n");
3707
                    goto fail;
3708
                } else if (c == 'M') {
3709
                    val <<= 20;
3710
                }
3711
                qdict_put(qdict, key, qint_from_int(val));
3712
            }
3713
            break;
3714
        case 'b':
3715
        case 'T':
3716
            {
3717
                double val;
3718

    
3719
                while (qemu_isspace(*p))
3720
                    p++;
3721
                if (*typestr == '?') {
3722
                    typestr++;
3723
                    if (*p == '\0') {
3724
                        break;
3725
                    }
3726
                }
3727
                if (get_double(mon, &val, &p) < 0) {
3728
                    goto fail;
3729
                }
3730
                if (c == 'b' && *p) {
3731
                    switch (*p) {
3732
                    case 'K': case 'k':
3733
                        val *= 1 << 10; p++; break;
3734
                    case 'M': case 'm':
3735
                        val *= 1 << 20; p++; break;
3736
                    case 'G': case 'g':
3737
                        val *= 1 << 30; p++; break;
3738
                    }
3739
                }
3740
                if (c == 'T' && p[0] && p[1] == 's') {
3741
                    switch (*p) {
3742
                    case 'm':
3743
                        val /= 1e3; p += 2; break;
3744
                    case 'u':
3745
                        val /= 1e6; p += 2; break;
3746
                    case 'n':
3747
                        val /= 1e9; p += 2; break;
3748
                    }
3749
                }
3750
                if (*p && !qemu_isspace(*p)) {
3751
                    monitor_printf(mon, "Unknown unit suffix\n");
3752
                    goto fail;
3753
                }
3754
                qdict_put(qdict, key, qfloat_from_double(val));
3755
            }
3756
            break;
3757
        case '-':
3758
            {
3759
                const char *tmp = p;
3760
                int has_option, skip_key = 0;
3761
                /* option */
3762

    
3763
                c = *typestr++;
3764
                if (c == '\0')
3765
                    goto bad_type;
3766
                while (qemu_isspace(*p))
3767
                    p++;
3768
                has_option = 0;
3769
                if (*p == '-') {
3770
                    p++;
3771
                    if(c != *p) {
3772
                        if(!is_valid_option(p, typestr)) {
3773
                  
3774
                            monitor_printf(mon, "%s: unsupported option -%c\n",
3775
                                           cmdname, *p);
3776
                            goto fail;
3777
                        } else {
3778
                            skip_key = 1;
3779
                        }
3780
                    }
3781
                    if(skip_key) {
3782
                        p = tmp;
3783
                    } else {
3784
                        p++;
3785
                        has_option = 1;
3786
                    }
3787
                }
3788
                qdict_put(qdict, key, qint_from_int(has_option));
3789
            }
3790
            break;
3791
        default:
3792
        bad_type:
3793
            monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
3794
            goto fail;
3795
        }
3796
        qemu_free(key);
3797
        key = NULL;
3798
    }
3799
    /* check that all arguments were parsed */
3800
    while (qemu_isspace(*p))
3801
        p++;
3802
    if (*p != '\0') {
3803
        monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3804
                       cmdname);
3805
        goto fail;
3806
    }
3807

    
3808
    return cmd;
3809

    
3810
fail:
3811
    qemu_free(key);
3812
    return NULL;
3813
}
3814

    
3815
void monitor_set_error(Monitor *mon, QError *qerror)
3816
{
3817
    /* report only the first error */
3818
    if (!mon->error) {
3819
        mon->error = qerror;
3820
    } else {
3821
        MON_DEBUG("Additional error report at %s:%d\n",
3822
                  qerror->file, qerror->linenr);
3823
        QDECREF(qerror);
3824
    }
3825
}
3826

    
3827
static int is_async_return(const QObject *data)
3828
{
3829
    if (data && qobject_type(data) == QTYPE_QDICT) {
3830
        return qdict_haskey(qobject_to_qdict(data), "__mon_async");
3831
    }
3832

    
3833
    return 0;
3834
}
3835

    
3836
static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
3837
{
3838
    if (monitor_ctrl_mode(mon)) {
3839
        if (ret && !monitor_has_error(mon)) {
3840
            /*
3841
             * If it returns failure, it must have passed on error.
3842
             *
3843
             * Action: Report an internal error to the client if in QMP.
3844
             */
3845
            qerror_report(QERR_UNDEFINED_ERROR);
3846
            MON_DEBUG("command '%s' returned failure but did not pass an error\n",
3847
                      cmd->name);
3848
        }
3849

    
3850
#ifdef CONFIG_DEBUG_MONITOR
3851
        if (!ret && monitor_has_error(mon)) {
3852
            /*
3853
             * If it returns success, it must not have passed an error.
3854
             *
3855
             * Action: Report the passed error to the client.
3856
             */
3857
            MON_DEBUG("command '%s' returned success but passed an error\n",
3858
                      cmd->name);
3859
        }
3860

    
3861
        if (mon_print_count_get(mon) > 0 && strcmp(cmd->name, "info") != 0) {
3862
            /*
3863
             * Handlers should not call Monitor print functions.
3864
             *
3865
             * Action: Ignore them in QMP.
3866
             *
3867
             * (XXX: we don't check any 'info' or 'query' command here
3868
             * because the user print function _is_ called by do_info(), hence
3869
             * we will trigger this check. This problem will go away when we
3870
             * make 'query' commands real and kill do_info())
3871
             */
3872
            MON_DEBUG("command '%s' called print functions %d time(s)\n",
3873
                      cmd->name, mon_print_count_get(mon));
3874
        }
3875
#endif
3876
    } else {
3877
        assert(!monitor_has_error(mon));
3878
        QDECREF(mon->error);
3879
        mon->error = NULL;
3880
    }
3881
}
3882

    
3883
static void monitor_call_handler(Monitor *mon, const mon_cmd_t *cmd,
3884
                                 const QDict *params)
3885
{
3886
    int ret;
3887
    QObject *data = NULL;
3888

    
3889
    mon_print_count_init(mon);
3890

    
3891
    ret = cmd->mhandler.cmd_new(mon, params, &data);
3892
    handler_audit(mon, cmd, ret);
3893

    
3894
    if (is_async_return(data)) {
3895
        /*
3896
         * Asynchronous commands have no initial return data but they can
3897
         * generate errors.  Data is returned via the async completion handler.
3898
         */
3899
        if (monitor_ctrl_mode(mon) && monitor_has_error(mon)) {
3900
            monitor_protocol_emitter(mon, NULL);
3901
        }
3902
    } else if (monitor_ctrl_mode(mon)) {
3903
        /* Monitor Protocol */
3904
        monitor_protocol_emitter(mon, data);
3905
    } else {
3906
        /* User Protocol */
3907
         if (data)
3908
            cmd->user_print(mon, data);
3909
    }
3910

    
3911
    qobject_decref(data);
3912
}
3913

    
3914
static void handle_user_command(Monitor *mon, const char *cmdline)
3915
{
3916
    QDict *qdict;
3917
    const mon_cmd_t *cmd;
3918

    
3919
    qdict = qdict_new();
3920

    
3921
    cmd = monitor_parse_command(mon, cmdline, qdict);
3922
    if (!cmd)
3923
        goto out;
3924

    
3925
    if (monitor_handler_is_async(cmd)) {
3926
        user_async_cmd_handler(mon, cmd, qdict);
3927
    } else if (monitor_handler_ported(cmd)) {
3928
        monitor_call_handler(mon, cmd, qdict);
3929
    } else {
3930
        cmd->mhandler.cmd(mon, qdict);
3931
    }
3932

    
3933
out:
3934
    QDECREF(qdict);
3935
}
3936

    
3937
static void cmd_completion(const char *name, const char *list)
3938
{
3939
    const char *p, *pstart;
3940
    char cmd[128];
3941
    int len;
3942

    
3943
    p = list;
3944
    for(;;) {
3945
        pstart = p;
3946
        p = strchr(p, '|');
3947
        if (!p)
3948
            p = pstart + strlen(pstart);
3949
        len = p - pstart;
3950
        if (len > sizeof(cmd) - 2)
3951
            len = sizeof(cmd) - 2;
3952
        memcpy(cmd, pstart, len);
3953
        cmd[len] = '\0';
3954
        if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3955
            readline_add_completion(cur_mon->rs, cmd);
3956
        }
3957
        if (*p == '\0')
3958
            break;
3959
        p++;
3960
    }
3961
}
3962

    
3963
static void file_completion(const char *input)
3964
{
3965
    DIR *ffs;
3966
    struct dirent *d;
3967
    char path[1024];
3968
    char file[1024], file_prefix[1024];
3969
    int input_path_len;
3970
    const char *p;
3971

    
3972
    p = strrchr(input, '/');
3973
    if (!p) {
3974
        input_path_len = 0;
3975
        pstrcpy(file_prefix, sizeof(file_prefix), input);
3976
        pstrcpy(path, sizeof(path), ".");
3977
    } else {
3978
        input_path_len = p - input + 1;
3979
        memcpy(path, input, input_path_len);
3980
        if (input_path_len > sizeof(path) - 1)
3981
            input_path_len = sizeof(path) - 1;
3982
        path[input_path_len] = '\0';
3983
        pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3984
    }
3985
#ifdef DEBUG_COMPLETION
3986
    monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
3987
                   input, path, file_prefix);
3988
#endif
3989
    ffs = opendir(path);
3990
    if (!ffs)
3991
        return;
3992
    for(;;) {
3993
        struct stat sb;
3994
        d = readdir(ffs);
3995
        if (!d)
3996
            break;
3997
        if (strstart(d->d_name, file_prefix, NULL)) {
3998
            memcpy(file, input, input_path_len);
3999
            if (input_path_len < sizeof(file))
4000
                pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4001
                        d->d_name);
4002
            /* stat the file to find out if it's a directory.
4003
             * In that case add a slash to speed up typing long paths
4004
             */
4005
            stat(file, &sb);
4006
            if(S_ISDIR(sb.st_mode))
4007
                pstrcat(file, sizeof(file), "/");
4008
            readline_add_completion(cur_mon->rs, file);
4009
        }
4010
    }
4011
    closedir(ffs);
4012
}
4013

    
4014
static void block_completion_it(void *opaque, BlockDriverState *bs)
4015
{
4016
    const char *name = bdrv_get_device_name(bs);
4017
    const char *input = opaque;
4018

    
4019
    if (input[0] == '\0' ||
4020
        !strncmp(name, (char *)input, strlen(input))) {
4021
        readline_add_completion(cur_mon->rs, name);
4022
    }
4023
}
4024

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

    
4033
    p = cmdline;
4034
    nb_args = 0;
4035
    for(;;) {
4036
        while (qemu_isspace(*p))
4037
            p++;
4038
        if (*p == '\0')
4039
            break;
4040
        if (nb_args >= MAX_ARGS)
4041
            break;
4042
        ret = get_str(buf, sizeof(buf), &p);
4043
        args[nb_args] = qemu_strdup(buf);
4044
        nb_args++;
4045
        if (ret < 0)
4046
            break;
4047
    }
4048
    *pnb_args = nb_args;
4049
}
4050

    
4051
static const char *next_arg_type(const char *typestr)
4052
{
4053
    const char *p = strchr(typestr, ':');
4054
    return (p != NULL ? ++p : typestr);
4055
}
4056

    
4057
static void monitor_find_completion(const char *cmdline)
4058
{
4059
    const char *cmdname;
4060
    char *args[MAX_ARGS];
4061
    int nb_args, i, len;
4062
    const char *ptype, *str;
4063
    const mon_cmd_t *cmd;
4064
    const KeyDef *key;
4065

    
4066
    parse_cmdline(cmdline, &nb_args, args);
4067
#ifdef DEBUG_COMPLETION
4068
    for(i = 0; i < nb_args; i++) {
4069
        monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
4070
    }
4071
#endif
4072

    
4073
    /* if the line ends with a space, it means we want to complete the
4074
       next arg */
4075
    len = strlen(cmdline);
4076
    if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4077
        if (nb_args >= MAX_ARGS)
4078
            return;
4079
        args[nb_args++] = qemu_strdup("");
4080
    }
4081
    if (nb_args <= 1) {
4082
        /* command completion */
4083
        if (nb_args == 0)
4084
            cmdname = "";
4085
        else
4086
            cmdname = args[0];
4087
        readline_set_completion_index(cur_mon->rs, strlen(cmdname));
4088
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
4089
            cmd_completion(cmdname, cmd->name);
4090
        }
4091
    } else {
4092
        /* find the command */
4093
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
4094
            if (compare_cmd(args[0], cmd->name))
4095
                goto found;
4096
        }
4097
        return;
4098
    found:
4099
        ptype = next_arg_type(cmd->args_type);
4100
        for(i = 0; i < nb_args - 2; i++) {
4101
            if (*ptype != '\0') {
4102
                ptype = next_arg_type(ptype);
4103
                while (*ptype == '?')
4104
                    ptype = next_arg_type(ptype);
4105
            }
4106
        }
4107
        str = args[nb_args - 1];
4108
        if (*ptype == '-' && ptype[1] != '\0') {
4109
            ptype += 2;
4110
        }
4111
        switch(*ptype) {
4112
        case 'F':
4113
            /* file completion */
4114
            readline_set_completion_index(cur_mon->rs, strlen(str));
4115
            file_completion(str);
4116
            break;
4117
        case 'B':
4118
            /* block device name completion */
4119
            readline_set_completion_index(cur_mon->rs, strlen(str));
4120
            bdrv_iterate(block_completion_it, (void *)str);
4121
            break;
4122
        case 's':
4123
            /* XXX: more generic ? */
4124
            if (!strcmp(cmd->name, "info")) {
4125
                readline_set_completion_index(cur_mon->rs, strlen(str));
4126
                for(cmd = info_cmds; cmd->name != NULL; cmd++) {
4127
                    cmd_completion(str, cmd->name);
4128
                }
4129
            } else if (!strcmp(cmd->name, "sendkey")) {
4130
                char *sep = strrchr(str, '-');
4131
                if (sep)
4132
                    str = sep + 1;
4133
                readline_set_completion_index(cur_mon->rs, strlen(str));
4134
                for(key = key_defs; key->name != NULL; key++) {
4135
                    cmd_completion(str, key->name);
4136
                }
4137
            } else if (!strcmp(cmd->name, "help|?")) {
4138
                readline_set_completion_index(cur_mon->rs, strlen(str));
4139
                for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4140
                    cmd_completion(str, cmd->name);
4141
                }
4142
            }
4143
            break;
4144
        default:
4145
            break;
4146
        }
4147
    }
4148
    for(i = 0; i < nb_args; i++)
4149
        qemu_free(args[i]);
4150
}
4151

    
4152
static int monitor_can_read(void *opaque)
4153
{
4154
    Monitor *mon = opaque;
4155

    
4156
    return (mon->suspend_cnt == 0) ? 1 : 0;
4157
}
4158

    
4159
typedef struct CmdArgs {
4160
    QString *name;
4161
    int type;
4162
    int flag;
4163
    int optional;
4164
} CmdArgs;
4165

    
4166
static int check_opt(const CmdArgs *cmd_args, const char *name, QDict *args)
4167
{
4168
    if (!cmd_args->optional) {
4169
        qerror_report(QERR_MISSING_PARAMETER, name);
4170
        return -1;
4171
    }
4172

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

    
4178
    return 0;
4179
}
4180

    
4181
static int check_arg(const CmdArgs *cmd_args, QDict *args)
4182
{
4183
    QObject *value;
4184
    const char *name;
4185

    
4186
    name = qstring_get_str(cmd_args->name);
4187

    
4188
    if (!args) {
4189
        return check_opt(cmd_args, name, args);
4190
    }
4191

    
4192
    value = qdict_get(args, name);
4193
    if (!value) {
4194
        return check_opt(cmd_args, name, args);
4195
    }
4196

    
4197
    switch (cmd_args->type) {
4198
        case 'F':
4199
        case 'B':
4200
        case 's':
4201
            if (qobject_type(value) != QTYPE_QSTRING) {
4202
                qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "string");
4203
                return -1;
4204
            }
4205
            break;
4206
        case '/': {
4207
            int i;
4208
            const char *keys[] = { "count", "format", "size", NULL };
4209

    
4210
            for (i = 0; keys[i]; i++) {
4211
                QObject *obj = qdict_get(args, keys[i]);
4212
                if (!obj) {
4213
                    qerror_report(QERR_MISSING_PARAMETER, name);
4214
                    return -1;
4215
                }
4216
                if (qobject_type(obj) != QTYPE_QINT) {
4217
                    qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "int");
4218
                    return -1;
4219
                }
4220
            }
4221
            break;
4222
        }
4223
        case 'i':
4224
        case 'l':
4225
        case 'M':
4226
            if (qobject_type(value) != QTYPE_QINT) {
4227
                qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "int");
4228
                return -1;
4229
            }
4230
            break;
4231
        case 'b':
4232
        case 'T':
4233
            if (qobject_type(value) != QTYPE_QINT && qobject_type(value) != QTYPE_QFLOAT) {
4234
                qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "number");
4235
                return -1;
4236
            }
4237
            break;
4238
        case '-':
4239
            if (qobject_type(value) != QTYPE_QINT &&
4240
                qobject_type(value) != QTYPE_QBOOL) {
4241
                qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "bool");
4242
                return -1;
4243
            }
4244
            if (qobject_type(value) == QTYPE_QBOOL) {
4245
                /* handlers expect a QInt, they need to be changed */
4246
                qdict_put(args, name,
4247
                         qint_from_int(qbool_get_int(qobject_to_qbool(value))));
4248
            }
4249
            break;
4250
        case 'O':
4251
        default:
4252
            /* impossible */
4253
            abort();
4254
    }
4255

    
4256
    return 0;
4257
}
4258

    
4259
static void cmd_args_init(CmdArgs *cmd_args)
4260
{
4261
    cmd_args->name = qstring_new();
4262
    cmd_args->type = cmd_args->flag = cmd_args->optional = 0;
4263
}
4264

    
4265
static int check_opts(QemuOptsList *opts_list, QDict *args)
4266
{
4267
    assert(!opts_list->desc->name);
4268
    return 0;
4269
}
4270

    
4271
/*
4272
 * This is not trivial, we have to parse Monitor command's argument
4273
 * type syntax to be able to check the arguments provided by clients.
4274
 *
4275
 * In the near future we will be using an array for that and will be
4276
 * able to drop all this parsing...
4277
 */
4278
static int monitor_check_qmp_args(const mon_cmd_t *cmd, QDict *args)
4279
{
4280
    int err;
4281
    const char *p;
4282
    CmdArgs cmd_args;
4283
    QemuOptsList *opts_list;
4284

    
4285
    if (cmd->args_type == NULL) {
4286
        return (qdict_size(args) == 0 ? 0 : -1);
4287
    }
4288

    
4289
    err = 0;
4290
    cmd_args_init(&cmd_args);
4291
    opts_list = NULL;
4292

    
4293
    for (p = cmd->args_type;; p++) {
4294
        if (*p == ':') {
4295
            cmd_args.type = *++p;
4296
            p++;
4297
            if (cmd_args.type == '-') {
4298
                cmd_args.flag = *p++;
4299
                cmd_args.optional = 1;
4300
            } else if (cmd_args.type == 'O') {
4301
                opts_list = qemu_find_opts(qstring_get_str(cmd_args.name));
4302
                assert(opts_list);
4303
            } else if (*p == '?') {
4304
                cmd_args.optional = 1;
4305
                p++;
4306
            }
4307

    
4308
            assert(*p == ',' || *p == '\0');
4309
            if (opts_list) {
4310
                err = check_opts(opts_list, args);
4311
                opts_list = NULL;
4312
            } else {
4313
                err = check_arg(&cmd_args, args);
4314
                QDECREF(cmd_args.name);
4315
                cmd_args_init(&cmd_args);
4316
            }
4317

    
4318
            if (err < 0) {
4319
                break;
4320
            }
4321
        } else {
4322
            qstring_append_chr(cmd_args.name, *p);
4323
        }
4324

    
4325
        if (*p == '\0') {
4326
            break;
4327
        }
4328
    }
4329

    
4330
    QDECREF(cmd_args.name);
4331
    return err;
4332
}
4333

    
4334
static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4335
{
4336
    int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4337
    return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4338
}
4339

    
4340
static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4341
{
4342
    int err;
4343
    QObject *obj;
4344
    QDict *input, *args;
4345
    const mon_cmd_t *cmd;
4346
    Monitor *mon = cur_mon;
4347
    const char *cmd_name, *info_item;
4348

    
4349
    args = NULL;
4350

    
4351
    obj = json_parser_parse(tokens, NULL);
4352
    if (!obj) {
4353
        // FIXME: should be triggered in json_parser_parse()
4354
        qerror_report(QERR_JSON_PARSING);
4355
        goto err_out;
4356
    } else if (qobject_type(obj) != QTYPE_QDICT) {
4357
        qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4358
        qobject_decref(obj);
4359
        goto err_out;
4360
    }
4361

    
4362
    input = qobject_to_qdict(obj);
4363

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

    
4367
    obj = qdict_get(input, "execute");
4368
    if (!obj) {
4369
        qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4370
        goto err_input;
4371
    } else if (qobject_type(obj) != QTYPE_QSTRING) {
4372
        qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "string");
4373
        goto err_input;
4374
    }
4375

    
4376
    cmd_name = qstring_get_str(qobject_to_qstring(obj));
4377

    
4378
    if (invalid_qmp_mode(mon, cmd_name)) {
4379
        qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4380
        goto err_input;
4381
    }
4382

    
4383
    /*
4384
     * XXX: We need this special case until we get info handlers
4385
     * converted into 'query-' commands
4386
     */
4387
    if (compare_cmd(cmd_name, "info")) {
4388
        qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4389
        goto err_input;
4390
    } else if (strstart(cmd_name, "query-", &info_item)) {
4391
        cmd = monitor_find_command("info");
4392
        qdict_put_obj(input, "arguments",
4393
                      qobject_from_jsonf("{ 'item': %s }", info_item));
4394
    } else {
4395
        cmd = monitor_find_command(cmd_name);
4396
        if (!cmd || !monitor_handler_ported(cmd)) {
4397
            qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4398
            goto err_input;
4399
        }
4400
    }
4401

    
4402
    obj = qdict_get(input, "arguments");
4403
    if (!obj) {
4404
        args = qdict_new();
4405
    } else {
4406
        args = qobject_to_qdict(obj);
4407
        QINCREF(args);
4408
    }
4409

    
4410
    QDECREF(input);
4411

    
4412
    err = monitor_check_qmp_args(cmd, args);
4413
    if (err < 0) {
4414
        goto err_out;
4415
    }
4416

    
4417
    if (monitor_handler_is_async(cmd)) {
4418
        qmp_async_cmd_handler(mon, cmd, args);
4419
    } else {
4420
        monitor_call_handler(mon, cmd, args);
4421
    }
4422
    goto out;
4423

    
4424
err_input:
4425
    QDECREF(input);
4426
err_out:
4427
    monitor_protocol_emitter(mon, NULL);
4428
out:
4429
    QDECREF(args);
4430
}
4431

    
4432
/**
4433
 * monitor_control_read(): Read and handle QMP input
4434
 */
4435
static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4436
{
4437
    Monitor *old_mon = cur_mon;
4438

    
4439
    cur_mon = opaque;
4440

    
4441
    json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
4442

    
4443
    cur_mon = old_mon;
4444
}
4445

    
4446
static void monitor_read(void *opaque, const uint8_t *buf, int size)
4447
{
4448
    Monitor *old_mon = cur_mon;
4449
    int i;
4450

    
4451
    cur_mon = opaque;
4452

    
4453
    if (cur_mon->rs) {
4454
        for (i = 0; i < size; i++)
4455
            readline_handle_byte(cur_mon->rs, buf[i]);
4456
    } else {
4457
        if (size == 0 || buf[size - 1] != 0)
4458
            monitor_printf(cur_mon, "corrupted command\n");
4459
        else
4460
            handle_user_command(cur_mon, (char *)buf);
4461
    }
4462

    
4463
    cur_mon = old_mon;
4464
}
4465

    
4466
static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
4467
{
4468
    monitor_suspend(mon);
4469
    handle_user_command(mon, cmdline);
4470
    monitor_resume(mon);
4471
}
4472

    
4473
int monitor_suspend(Monitor *mon)
4474
{
4475
    if (!mon->rs)
4476
        return -ENOTTY;
4477
    mon->suspend_cnt++;
4478
    return 0;
4479
}
4480

    
4481
void monitor_resume(Monitor *mon)
4482
{
4483
    if (!mon->rs)
4484
        return;
4485
    if (--mon->suspend_cnt == 0)
4486
        readline_show_prompt(mon->rs);
4487
}
4488

    
4489
static QObject *get_qmp_greeting(void)
4490
{
4491
    QObject *ver;
4492

    
4493
    do_info_version(NULL, &ver);
4494
    return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4495
}
4496

    
4497
/**
4498
 * monitor_control_event(): Print QMP gretting
4499
 */
4500
static void monitor_control_event(void *opaque, int event)
4501
{
4502
    QObject *data;
4503
    Monitor *mon = opaque;
4504

    
4505
    switch (event) {
4506
    case CHR_EVENT_OPENED:
4507
        mon->mc->command_mode = 0;
4508
        json_message_parser_init(&mon->mc->parser, handle_qmp_command);
4509
        data = get_qmp_greeting();
4510
        monitor_json_emitter(mon, data);
4511
        qobject_decref(data);
4512
        break;
4513
    case CHR_EVENT_CLOSED:
4514
        json_message_parser_destroy(&mon->mc->parser);
4515
        break;
4516
    }
4517
}
4518

    
4519
static void monitor_event(void *opaque, int event)
4520
{
4521
    Monitor *mon = opaque;
4522

    
4523
    switch (event) {
4524
    case CHR_EVENT_MUX_IN:
4525
        mon->mux_out = 0;
4526
        if (mon->reset_seen) {
4527
            readline_restart(mon->rs);
4528
            monitor_resume(mon);
4529
            monitor_flush(mon);
4530
        } else {
4531
            mon->suspend_cnt = 0;
4532
        }
4533
        break;
4534

    
4535
    case CHR_EVENT_MUX_OUT:
4536
        if (mon->reset_seen) {
4537
            if (mon->suspend_cnt == 0) {
4538
                monitor_printf(mon, "\n");
4539
            }
4540
            monitor_flush(mon);
4541
            monitor_suspend(mon);
4542
        } else {
4543
            mon->suspend_cnt++;
4544
        }
4545
        mon->mux_out = 1;
4546
        break;
4547

    
4548
    case CHR_EVENT_OPENED:
4549
        monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4550
                       "information\n", QEMU_VERSION);
4551
        if (!mon->mux_out) {
4552
            readline_show_prompt(mon->rs);
4553
        }
4554
        mon->reset_seen = 1;
4555
        break;
4556
    }
4557
}
4558

    
4559

    
4560
/*
4561
 * Local variables:
4562
 *  c-indent-level: 4
4563
 *  c-basic-offset: 4
4564
 *  tab-width: 8
4565
 * End:
4566
 */
4567

    
4568
void monitor_init(CharDriverState *chr, int flags)
4569
{
4570
    static int is_first_init = 1;
4571
    Monitor *mon;
4572

    
4573
    if (is_first_init) {
4574
        key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
4575
        is_first_init = 0;
4576
    }
4577

    
4578
    mon = qemu_mallocz(sizeof(*mon));
4579

    
4580
    mon->chr = chr;
4581
    mon->flags = flags;
4582
    if (flags & MONITOR_USE_READLINE) {
4583
        mon->rs = readline_init(mon, monitor_find_completion);
4584
        monitor_read_command(mon, 0);
4585
    }
4586

    
4587
    if (monitor_ctrl_mode(mon)) {
4588
        mon->mc = qemu_mallocz(sizeof(MonitorControl));
4589
        /* Control mode requires special handlers */
4590
        qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4591
                              monitor_control_event, mon);
4592
    } else {
4593
        qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4594
                              monitor_event, mon);
4595
    }
4596

    
4597
    QLIST_INSERT_HEAD(&mon_list, mon, entry);
4598
    if (!default_mon || (flags & MONITOR_IS_DEFAULT))
4599
        default_mon = mon;
4600
}
4601

    
4602
static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
4603
{
4604
    BlockDriverState *bs = opaque;
4605
    int ret = 0;
4606

    
4607
    if (bdrv_set_key(bs, password) != 0) {
4608
        monitor_printf(mon, "invalid password\n");
4609
        ret = -EPERM;
4610
    }
4611
    if (mon->password_completion_cb)
4612
        mon->password_completion_cb(mon->password_opaque, ret);
4613

    
4614
    monitor_read_command(mon, 1);
4615
}
4616

    
4617
int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4618
                                BlockDriverCompletionFunc *completion_cb,
4619
                                void *opaque)
4620
{
4621
    int err;
4622

    
4623
    if (!bdrv_key_required(bs)) {
4624
        if (completion_cb)
4625
            completion_cb(opaque, 0);
4626
        return 0;
4627
    }
4628

    
4629
    if (monitor_ctrl_mode(mon)) {
4630
        qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
4631
        return -1;
4632
    }
4633

    
4634
    monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),