Blame view

monitor.c 84.8 KB
bellard authored
1
2
/*
 * QEMU monitor
3
 *
bellard authored
4
 * Copyright (c) 2003-2004 Fabrice Bellard
5
 *
bellard authored
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
24
#include <dirent.h>
pbrook authored
25
#include "hw/hw.h"
26
#include "hw/qdev.h"
pbrook authored
27
28
29
30
#include "hw/usb.h"
#include "hw/pcmcia.h"
#include "hw/pc.h"
#include "hw/pci.h"
Richard W.M. Jones authored
31
#include "hw/watchdog.h"
pbrook authored
32
33
34
35
#include "gdbstub.h"
#include "net.h"
#include "qemu-char.h"
#include "sysemu.h"
36
37
#include "monitor.h"
#include "readline.h"
pbrook authored
38
39
40
#include "console.h"
#include "block.h"
#include "audio/audio.h"
41
#include "disas.h"
42
#include "balloon.h"
43
#include "qemu-timer.h"
44
#include "migration.h"
aliguori authored
45
#include "kvm.h"
46
#include "acl.h"
ths authored
47
bellard authored
48
//#define DEBUG
bellard authored
49
//#define DEBUG_COMPLETION
bellard authored
50
51
52
/*
 * Supported types:
53
 *
54
 * 'F'          filename
bellard authored
55
 * 'B'          block device name
56
 * 's'          string (accept optional quote)
bellard authored
57
58
 * 'i'          32 bit integer
 * 'l'          target long (32 or 64 bit)
59
60
61
62
63
64
 * '/'          optional gdb-like print format (like "/10x")
 *
 * '?'          optional type (for 'F', 's' and 'i')
 *
 */
65
typedef struct mon_cmd_t {
bellard authored
66
    const char *name;
67
    const char *args_type;
68
    void *handler;
bellard authored
69
70
    const char *params;
    const char *help;
71
} mon_cmd_t;
bellard authored
72
73
74
struct Monitor {
    CharDriverState *chr;
75
76
77
78
79
80
81
82
    int flags;
    int suspend_cnt;
    uint8_t outbuf[1024];
    int outbuf_index;
    ReadLineState *rs;
    CPUState *mon_cpu;
    BlockDriverCompletionFunc *password_completion_cb;
    void *password_opaque;
83
84
85
86
    LIST_ENTRY(Monitor) entry;
};

static LIST_HEAD(mon_list, Monitor) mon_list;
87
88
89
static const mon_cmd_t mon_cmds[];
static const mon_cmd_t info_cmds[];
bellard authored
90
91
Monitor *cur_mon = NULL;
92
93
94
static void monitor_command_cb(Monitor *mon, const char *cmdline,
                               void *opaque);
95
96
97
98
99
100
101
static void monitor_read_command(Monitor *mon, int show_prompt)
{
    readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
    if (show_prompt)
        readline_show_prompt(mon->rs);
}
bellard authored
102
103
104
static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
                                 void *opaque)
105
{
106
107
108
109
110
111
112
113
    if (mon->rs) {
        readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
        /* prompt is printed on return from the command handler */
        return 0;
    } else {
        monitor_printf(mon, "terminal does not support password prompting\n");
        return -ENOTTY;
    }
114
115
}
116
void monitor_flush(Monitor *mon)
117
{
118
119
120
    if (mon && mon->outbuf_index != 0 && mon->chr->focus == 0) {
        qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
        mon->outbuf_index = 0;
121
122
123
124
    }
}

/* flush at every end of line or if the buffer is full */
125
static void monitor_puts(Monitor *mon, const char *str)
126
{
127
    char c;
128
129
130
131

    if (!mon)
        return;
132
133
134
135
    for(;;) {
        c = *str++;
        if (c == '\0')
            break;
bellard authored
136
        if (c == '\n')
137
138
139
140
            mon->outbuf[mon->outbuf_index++] = '\r';
        mon->outbuf[mon->outbuf_index++] = c;
        if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
            || c == '\n')
141
            monitor_flush(mon);
142
143
144
    }
}
145
void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
bellard authored
146
{
bellard authored
147
148
    char buf[4096];
    vsnprintf(buf, sizeof(buf), fmt, ap);
149
    monitor_puts(mon, buf);
bellard authored
150
151
}
152
void monitor_printf(Monitor *mon, const char *fmt, ...)
bellard authored
153
{
154
155
    va_list ap;
    va_start(ap, fmt);
156
    monitor_vprintf(mon, fmt, ap);
157
    va_end(ap);
bellard authored
158
159
}
160
void monitor_print_filename(Monitor *mon, const char *filename)
161
162
163
164
{
    int i;

    for (i = 0; filename[i]; i++) {
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
        switch (filename[i]) {
        case ' ':
        case '"':
        case '\\':
            monitor_printf(mon, "\\%c", filename[i]);
            break;
        case '\t':
            monitor_printf(mon, "\\t");
            break;
        case '\r':
            monitor_printf(mon, "\\r");
            break;
        case '\n':
            monitor_printf(mon, "\\n");
            break;
        default:
            monitor_printf(mon, "%c", filename[i]);
            break;
        }
184
185
186
    }
}
bellard authored
187
188
189
190
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
191
    monitor_vprintf((Monitor *)stream, fmt, ap);
bellard authored
192
193
194
195
    va_end(ap);
    return 0;
}
bellard authored
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
static int compare_cmd(const char *name, const char *list)
{
    const char *p, *pstart;
    int len;
    len = strlen(name);
    p = list;
    for(;;) {
        pstart = p;
        p = strchr(p, '|');
        if (!p)
            p = pstart + strlen(pstart);
        if ((p - pstart) == len && !memcmp(pstart, name, len))
            return 1;
        if (*p == '\0')
            break;
        p++;
    }
    return 0;
}
216
217
static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
                          const char *prefix, const char *name)
bellard authored
218
{
219
    const mon_cmd_t *cmd;
bellard authored
220
221
222

    for(cmd = cmds; cmd->name != NULL; cmd++) {
        if (!name || !strcmp(name, cmd->name))
223
224
            monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
                           cmd->params, cmd->help);
bellard authored
225
226
227
    }
}
228
static void help_cmd(Monitor *mon, const char *name)
bellard authored
229
230
{
    if (name && !strcmp(name, "info")) {
231
        help_cmd_dump(mon, info_cmds, "info ", NULL);
bellard authored
232
    } else {
233
        help_cmd_dump(mon, mon_cmds, "", name);
234
        if (name && !strcmp(name, "log")) {
235
            const CPULogItem *item;
236
237
            monitor_printf(mon, "Log items (comma separated):\n");
            monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
238
            for(item = cpu_log_items; item->mask != 0; item++) {
239
                monitor_printf(mon, "%-10s %s\n", item->name, item->help);
240
241
            }
        }
bellard authored
242
243
244
    }
}
245
static void do_commit(Monitor *mon, const char *device)
bellard authored
246
{
bellard authored
247
    int i, all_devices;
248
bellard authored
249
    all_devices = !strcmp(device, "all");
250
    for (i = 0; i < nb_drives; i++) {
251
            if (all_devices ||
252
253
                !strcmp(bdrv_get_device_name(drives_table[i].bdrv), device))
                bdrv_commit(drives_table[i].bdrv);
bellard authored
254
255
256
    }
}
257
static void do_info(Monitor *mon, const char *item)
bellard authored
258
{
259
260
    const mon_cmd_t *cmd;
    void (*handler)(Monitor *);
bellard authored
261
262
    if (!item)
bellard authored
263
264
        goto help;
    for(cmd = info_cmds; cmd->name != NULL; cmd++) {
265
        if (compare_cmd(item, cmd->name))
bellard authored
266
267
268
            goto found;
    }
 help:
269
    help_cmd(mon, "info");
bellard authored
270
271
    return;
 found:
272
    handler = cmd->handler;
273
    handler(mon);
bellard authored
274
275
}
276
static void do_info_version(Monitor *mon)
bellard authored
277
{
pbrook authored
278
    monitor_printf(mon, "%s\n", QEMU_VERSION QEMU_PKGVERSION);
bellard authored
279
280
}
281
static void do_info_name(Monitor *mon)
282
283
{
    if (qemu_name)
284
        monitor_printf(mon, "%s\n", qemu_name);
285
286
}
287
#if defined(TARGET_I386)
288
static void do_info_hpet(Monitor *mon)
289
{
290
291
    monitor_printf(mon, "HPET is %s by QEMU\n",
                   (no_hpet) ? "disabled" : "enabled");
292
}
293
#endif
294
295
static void do_info_uuid(Monitor *mon)
296
{
297
298
299
300
301
    monitor_printf(mon, UUID_FMT "\n", qemu_uuid[0], qemu_uuid[1],
                   qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
                   qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
                   qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
                   qemu_uuid[14], qemu_uuid[15]);
302
303
}
bellard authored
304
/* get the current CPU defined by the user */
305
static int mon_set_cpu(int cpu_index)
bellard authored
306
307
308
309
310
{
    CPUState *env;

    for(env = first_cpu; env != NULL; env = env->next_cpu) {
        if (env->cpu_index == cpu_index) {
311
            cur_mon->mon_cpu = env;
bellard authored
312
313
314
315
316
317
            return 0;
        }
    }
    return -1;
}
318
static CPUState *mon_get_cpu(void)
bellard authored
319
{
320
    if (!cur_mon->mon_cpu) {
bellard authored
321
322
        mon_set_cpu(0);
    }
323
    cpu_synchronize_state(cur_mon->mon_cpu, 0);
324
    return cur_mon->mon_cpu;
bellard authored
325
326
}
327
static void do_info_registers(Monitor *mon)
328
{
bellard authored
329
330
331
332
    CPUState *env;
    env = mon_get_cpu();
    if (!env)
        return;
333
#ifdef TARGET_I386
334
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
bellard authored
335
                   X86_DUMP_FPU);
336
#else
337
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
bellard authored
338
                   0);
339
340
341
#endif
}
342
static void do_info_cpus(Monitor *mon)
bellard authored
343
344
345
346
347
348
349
{
    CPUState *env;

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

    for(env = first_cpu; env != NULL; env = env->next_cpu) {
350
        cpu_synchronize_state(env, 0);
351
        monitor_printf(mon, "%c CPU #%d:",
352
                       (env == mon->mon_cpu) ? '*' : ' ',
353
                       env->cpu_index);
bellard authored
354
#if defined(TARGET_I386)
355
356
        monitor_printf(mon, " pc=0x" TARGET_FMT_lx,
                       env->eip + env->segs[R_CS].base);
bellard authored
357
#elif defined(TARGET_PPC)
358
        monitor_printf(mon, " nip=0x" TARGET_FMT_lx, env->nip);
359
#elif defined(TARGET_SPARC)
360
361
        monitor_printf(mon, " pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx,
                       env->pc, env->npc);
362
#elif defined(TARGET_MIPS)
363
        monitor_printf(mon, " PC=0x" TARGET_FMT_lx, env->active_tc.PC);
364
#endif
365
        if (env->halted)
366
367
            monitor_printf(mon, " (halted)");
        monitor_printf(mon, "\n");
bellard authored
368
369
370
    }
}
371
static void do_cpu_set(Monitor *mon, int index)
bellard authored
372
373
{
    if (mon_set_cpu(index) < 0)
374
        monitor_printf(mon, "Invalid CPU index\n");
bellard authored
375
376
}
377
static void do_info_jit(Monitor *mon)
bellard authored
378
{
379
    dump_exec_info((FILE *)mon, monitor_fprintf);
bellard authored
380
381
}
382
static void do_info_history(Monitor *mon)
383
384
{
    int i;
385
    const char *str;
386
387
388
    if (!mon->rs)
        return;
389
390
    i = 0;
    for(;;) {
391
        str = readline_get_history(mon->rs, i);
392
393
        if (!str)
            break;
394
        monitor_printf(mon, "%d: '%s'\n", i, str);
395
        i++;
396
397
398
    }
}
399
400
#if defined(TARGET_PPC)
/* XXX: not implemented in other targets */
401
static void do_info_cpu_stats(Monitor *mon)
402
403
404
405
{
    CPUState *env;

    env = mon_get_cpu();
406
    cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
407
408
409
}
#endif
410
static void do_quit(Monitor *mon)
bellard authored
411
412
413
414
{
    exit(0);
}
415
static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
bellard authored
416
417
418
419
{
    if (bdrv_is_inserted(bs)) {
        if (!force) {
            if (!bdrv_is_removable(bs)) {
420
                monitor_printf(mon, "device is not removable\n");
bellard authored
421
422
423
                return -1;
            }
            if (bdrv_is_locked(bs)) {
424
                monitor_printf(mon, "device is locked\n");
bellard authored
425
426
427
428
429
430
431
432
                return -1;
            }
        }
        bdrv_close(bs);
    }
    return 0;
}
433
static void do_eject(Monitor *mon, int force, const char *filename)
bellard authored
434
435
436
{
    BlockDriverState *bs;
437
    bs = bdrv_find(filename);
bellard authored
438
    if (!bs) {
439
        monitor_printf(mon, "device not found\n");
bellard authored
440
441
        return;
    }
442
    eject_device(mon, bs, force);
bellard authored
443
444
}
445
446
static void do_change_block(Monitor *mon, const char *device,
                            const char *filename, const char *fmt)
bellard authored
447
448
{
    BlockDriverState *bs;
449
    BlockDriver *drv = NULL;
bellard authored
450
451
    bs = bdrv_find(device);
bellard authored
452
    if (!bs) {
453
        monitor_printf(mon, "device not found\n");
bellard authored
454
455
        return;
    }
456
457
458
    if (fmt) {
        drv = bdrv_find_format(fmt);
        if (!drv) {
459
            monitor_printf(mon, "invalid format %s\n", fmt);
460
461
462
            return;
        }
    }
463
    if (eject_device(mon, bs, 0) < 0)
bellard authored
464
        return;
465
    bdrv_open2(bs, filename, 0, drv);
466
    monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
467
468
}
469
470
static void change_vnc_password_cb(Monitor *mon, const char *password,
                                   void *opaque)
471
472
{
    if (vnc_display_password(NULL, password) < 0)
473
        monitor_printf(mon, "could not set VNC server password\n");
474
475
    monitor_read_command(mon, 1);
bellard authored
476
477
}
478
static void do_change_vnc(Monitor *mon, const char *target, const char *arg)
479
{
480
    if (strcmp(target, "passwd") == 0 ||
481
482
        strcmp(target, "password") == 0) {
        if (arg) {
483
            char password[9];
484
485
            strncpy(password, arg, sizeof(password));
            password[sizeof(password) - 1] = '\0';
486
            change_vnc_password_cb(mon, password, NULL);
487
        } else {
488
            monitor_read_password(mon, change_vnc_password_cb, NULL);
489
        }
490
    } else {
491
        if (vnc_display_open(NULL, target) < 0)
492
            monitor_printf(mon, "could not start VNC server on %s\n", target);
493
    }
494
495
}
496
497
static void do_change(Monitor *mon, const char *device, const char *target,
                      const char *arg)
498
499
{
    if (strcmp(device, "vnc") == 0) {
500
        do_change_vnc(mon, target, arg);
501
    } else {
502
        do_change_block(mon, device, target, arg);
503
504
505
    }
}
506
static void do_screen_dump(Monitor *mon, const char *filename)
507
{
508
    vga_hw_screen_dump(filename);
509
510
}
511
static void do_logfile(Monitor *mon, const char *filename)
pbrook authored
512
513
514
515
{
    cpu_set_log_filename(filename);
}
516
static void do_log(Monitor *mon, const char *items)
517
518
{
    int mask;
519
520
    if (!strcmp(items, "none")) {
521
522
        mask = 0;
    } else {
523
        mask = cpu_str_to_log_mask(items);
524
        if (!mask) {
525
            help_cmd(mon, "log");
526
527
528
529
530
531
            return;
        }
    }
    cpu_set_log(mask);
}
532
533
534
535
536
537
538
539
540
541
542
static void do_singlestep(Monitor *mon, const char *option)
{
    if (!option || !strcmp(option, "on")) {
        singlestep = 1;
    } else if (!strcmp(option, "off")) {
        singlestep = 0;
    } else {
        monitor_printf(mon, "unexpected option %s\n", option);
    }
}
543
static void do_stop(Monitor *mon)
544
545
546
547
{
    vm_stop(EXCP_INTERRUPT);
}
548
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
549
550
551
552
553
554
555
struct bdrv_iterate_context {
    Monitor *mon;
    int err;
};

static void do_cont(Monitor *mon)
556
{
557
    struct bdrv_iterate_context context = { mon, 0 };
558
559
    bdrv_iterate(encrypted_bdrv_it, &context);
560
    /* only resume the vm if all keys are set and valid */
561
    if (!context.err)
562
        vm_start();
563
564
}
565
566
static void bdrv_key_cb(void *opaque, int err)
{
567
568
    Monitor *mon = opaque;
569
570
    /* another key was set successfully, retry to continue */
    if (!err)
571
        do_cont(mon);
572
573
574
575
}

static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
{
576
    struct bdrv_iterate_context *context = opaque;
577
578
579
580
581
    if (!context->err && bdrv_key_required(bs)) {
        context->err = -EBUSY;
        monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
                                    context->mon);
582
583
584
    }
}
585
586
587
588
589
590
591
592
static void do_gdbserver(Monitor *mon, const char *device)
{
    if (!device)
        device = "tcp::" DEFAULT_GDBSTUB_PORT;
    if (gdbserver_start(device) < 0) {
        monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
                       device);
    } else if (strcmp(device, "none") == 0) {
593
        monitor_printf(mon, "Disabled gdbserver\n");
594
    } else {
595
596
        monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
                       device);
597
598
599
    }
}
Richard W.M. Jones authored
600
601
602
603
604
605
606
static void do_watchdog_action(Monitor *mon, const char *action)
{
    if (select_watchdog_action(action) == -1) {
        monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
    }
}
607
static void monitor_printc(Monitor *mon, int c)
608
{
609
    monitor_printf(mon, "'");
610
611
    switch(c) {
    case '\'':
612
        monitor_printf(mon, "\\'");
613
614
        break;
    case '\\':
615
        monitor_printf(mon, "\\\\");
616
617
        break;
    case '\n':
618
        monitor_printf(mon, "\\n");
619
620
        break;
    case '\r':
621
        monitor_printf(mon, "\\r");
622
623
624
        break;
    default:
        if (c >= 32 && c <= 126) {
625
            monitor_printf(mon, "%c", c);
626
        } else {
627
            monitor_printf(mon, "\\x%02x", c);
628
629
630
        }
        break;
    }
631
    monitor_printf(mon, "'");
632
633
}
634
static void memory_dump(Monitor *mon, int count, int format, int wsize,
635
                        target_phys_addr_t addr, int is_physical)
636
{
bellard authored
637
    CPUState *env;
638
639
640
641
642
643
644
    int nb_per_line, l, line_size, i, max_digits, len;
    uint8_t buf[16];
    uint64_t v;

    if (format == 'i') {
        int flags;
        flags = 0;
bellard authored
645
646
647
        env = mon_get_cpu();
        if (!env && !is_physical)
            return;
648
#ifdef TARGET_I386
649
        if (wsize == 2) {
650
            flags = 1;
651
652
653
        } else if (wsize == 4) {
            flags = 0;
        } else {
bellard authored
654
            /* as default we use the current CS size */
655
            flags = 0;
bellard authored
656
657
            if (env) {
#ifdef TARGET_X86_64
658
                if ((env->efer & MSR_EFER_LMA) &&
bellard authored
659
660
661
662
663
664
665
                    (env->segs[R_CS].flags & DESC_L_MASK))
                    flags = 2;
                else
#endif
                if (!(env->segs[R_CS].flags & DESC_B_MASK))
                    flags = 1;
            }
666
667
        }
#endif
668
        monitor_disas(mon, env, addr, count, is_physical, flags);
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
        return;
    }

    len = wsize * count;
    if (wsize == 1)
        line_size = 8;
    else
        line_size = 16;
    nb_per_line = line_size / wsize;
    max_digits = 0;

    switch(format) {
    case 'o':
        max_digits = (wsize * 8 + 2) / 3;
        break;
    default:
    case 'x':
        max_digits = (wsize * 8) / 4;
        break;
    case 'u':
    case 'd':
        max_digits = (wsize * 8 * 10 + 32) / 33;
        break;
    case 'c':
        wsize = 1;
        break;
    }

    while (len > 0) {
698
        if (is_physical)
699
            monitor_printf(mon, TARGET_FMT_plx ":", addr);
700
        else
701
            monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
702
703
704
705
706
707
        l = len;
        if (l > line_size)
            l = line_size;
        if (is_physical) {
            cpu_physical_memory_rw(addr, buf, l, 0);
        } else {
bellard authored
708
709
710
            env = mon_get_cpu();
            if (!env)
                break;
711
            if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
712
                monitor_printf(mon, " Cannot access memory\n");
713
714
                break;
            }
715
        }
716
        i = 0;
717
718
719
720
721
722
723
724
725
726
        while (i < l) {
            switch(wsize) {
            default:
            case 1:
                v = ldub_raw(buf + i);
                break;
            case 2:
                v = lduw_raw(buf + i);
                break;
            case 4:
bellard authored
727
                v = (uint32_t)ldl_raw(buf + i);
728
729
730
731
732
                break;
            case 8:
                v = ldq_raw(buf + i);
                break;
            }
733
            monitor_printf(mon, " ");
734
735
            switch(format) {
            case 'o':
736
                monitor_printf(mon, "%#*" PRIo64, max_digits, v);
737
738
                break;
            case 'x':
739
                monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
740
741
                break;
            case 'u':
742
                monitor_printf(mon, "%*" PRIu64, max_digits, v);
743
744
                break;
            case 'd':
745
                monitor_printf(mon, "%*" PRId64, max_digits, v);
746
747
                break;
            case 'c':
748
                monitor_printc(mon, v);
749
750
751
752
                break;
            }
            i += wsize;
        }
753
        monitor_printf(mon, "\n");
754
755
756
757
758
        addr += l;
        len -= l;
    }
}
bellard authored
759
760
761
762
763
764
#if TARGET_LONG_BITS == 64
#define GET_TLONG(h, l) (((uint64_t)(h) << 32) | (l))
#else
#define GET_TLONG(h, l) (l)
#endif
765
static void do_memory_dump(Monitor *mon, int count, int format, int size,
bellard authored
766
                           uint32_t addrh, uint32_t addrl)
767
{
bellard authored
768
    target_long addr = GET_TLONG(addrh, addrl);
769
    memory_dump(mon, count, format, size, addr, 0);
770
771
}
772
773
774
775
776
777
#if TARGET_PHYS_ADDR_BITS > 32
#define GET_TPHYSADDR(h, l) (((uint64_t)(h) << 32) | (l))
#else
#define GET_TPHYSADDR(h, l) (l)
#endif
778
779
static void do_physical_memory_dump(Monitor *mon, int count, int format,
                                    int size, uint32_t addrh, uint32_t addrl)
bellard authored
780
781
{
782
    target_phys_addr_t addr = GET_TPHYSADDR(addrh, addrl);
783
    memory_dump(mon, count, format, size, addr, 1);
784
785
}
786
787
static void do_print(Monitor *mon, int count, int format, int size,
                     unsigned int valh, unsigned int vall)
788
{
789
790
    target_phys_addr_t val = GET_TPHYSADDR(valh, vall);
#if TARGET_PHYS_ADDR_BITS == 32
791
792
    switch(format) {
    case 'o':
793
        monitor_printf(mon, "%#o", val);
794
795
        break;
    case 'x':
796
        monitor_printf(mon, "%#x", val);
797
798
        break;
    case 'u':
799
        monitor_printf(mon, "%u", val);
800
801
802
        break;
    default:
    case 'd':
803
        monitor_printf(mon, "%d", val);
804
805
        break;
    case 'c':
806
        monitor_printc(mon, val);
807
808
        break;
    }
bellard authored
809
810
811
#else
    switch(format) {
    case 'o':
812
        monitor_printf(mon, "%#" PRIo64, val);
bellard authored
813
814
        break;
    case 'x':
815
        monitor_printf(mon, "%#" PRIx64, val);
bellard authored
816
817
        break;
    case 'u':
818
        monitor_printf(mon, "%" PRIu64, val);
bellard authored
819
820
821
        break;
    default:
    case 'd':
822
        monitor_printf(mon, "%" PRId64, val);
bellard authored
823
824
        break;
    case 'c':
825
        monitor_printc(mon, val);
bellard authored
826
827
828
        break;
    }
#endif
829
    monitor_printf(mon, "\n");
830
831
}
832
static void do_memory_save(Monitor *mon, unsigned int valh, unsigned int vall,
bellard authored
833
834
835
836
837
838
839
840
841
842
843
844
845
846
                           uint32_t size, const char *filename)
{
    FILE *f;
    target_long addr = GET_TLONG(valh, vall);
    uint32_t l;
    CPUState *env;
    uint8_t buf[1024];

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

    f = fopen(filename, "wb");
    if (!f) {
847
        monitor_printf(mon, "could not open '%s'\n", filename);
bellard authored
848
849
850
851
852
853
854
855
856
857
858
859
860
861
        return;
    }
    while (size != 0) {
        l = sizeof(buf);
        if (l > size)
            l = size;
        cpu_memory_rw_debug(env, addr, buf, l, 0);
        fwrite(buf, 1, l, f);
        addr += l;
        size -= l;
    }
    fclose(f);
}
862
863
864
static void do_physical_memory_save(Monitor *mon, unsigned int valh,
                                    unsigned int vall, uint32_t size,
                                    const char *filename)
aurel32 authored
865
866
867
868
{
    FILE *f;
    uint32_t l;
    uint8_t buf[1024];
869
    target_phys_addr_t addr = GET_TPHYSADDR(valh, vall); 
aurel32 authored
870
871
872

    f = fopen(filename, "wb");
    if (!f) {
873
        monitor_printf(mon, "could not open '%s'\n", filename);
aurel32 authored
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
        return;
    }
    while (size != 0) {
        l = sizeof(buf);
        if (l > size)
            l = size;
        cpu_physical_memory_rw(addr, buf, l, 0);
        fwrite(buf, 1, l, f);
        fflush(f);
        addr += l;
        size -= l;
    }
    fclose(f);
}
889
static void do_sum(Monitor *mon, uint32_t start, uint32_t size)
bellard authored
890
891
892
893
894
895
896
897
898
899
900
901
{
    uint32_t addr;
    uint8_t buf[1];
    uint16_t sum;

    sum = 0;
    for(addr = start; addr < (start + size); addr++) {
        cpu_physical_memory_rw(addr, buf, 1, 0);
        /* BSD sum algorithm ('sum' Unix command) */
        sum = (sum >> 1) | (sum << 15);
        sum += buf[0];
    }
902
    monitor_printf(mon, "%05d\n", sum);
bellard authored
903
904
}
bellard authored
905
906
907
908
909
910
911
912
typedef struct {
    int keycode;
    const char *name;
} KeyDef;

static const KeyDef key_defs[] = {
    { 0x2a, "shift" },
    { 0x36, "shift_r" },
913
bellard authored
914
915
    { 0x38, "alt" },
    { 0xb8, "alt_r" },
916
917
    { 0x64, "altgr" },
    { 0xe4, "altgr_r" },
bellard authored
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
    { 0x1d, "ctrl" },
    { 0x9d, "ctrl_r" },

    { 0xdd, "menu" },

    { 0x01, "esc" },

    { 0x02, "1" },
    { 0x03, "2" },
    { 0x04, "3" },
    { 0x05, "4" },
    { 0x06, "5" },
    { 0x07, "6" },
    { 0x08, "7" },
    { 0x09, "8" },
    { 0x0a, "9" },
    { 0x0b, "0" },
935
936
    { 0x0c, "minus" },
    { 0x0d, "equal" },
bellard authored
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
    { 0x0e, "backspace" },

    { 0x0f, "tab" },
    { 0x10, "q" },
    { 0x11, "w" },
    { 0x12, "e" },
    { 0x13, "r" },
    { 0x14, "t" },
    { 0x15, "y" },
    { 0x16, "u" },
    { 0x17, "i" },
    { 0x18, "o" },
    { 0x19, "p" },

    { 0x1c, "ret" },

    { 0x1e, "a" },
    { 0x1f, "s" },
    { 0x20, "d" },
    { 0x21, "f" },
    { 0x22, "g" },
    { 0x23, "h" },
    { 0x24, "j" },
    { 0x25, "k" },
    { 0x26, "l" },

    { 0x2c, "z" },
    { 0x2d, "x" },
    { 0x2e, "c" },
    { 0x2f, "v" },
    { 0x30, "b" },
    { 0x31, "n" },
    { 0x32, "m" },
970
971
972
    { 0x33, "comma" },
    { 0x34, "dot" },
    { 0x35, "slash" },
973
balrog authored
974
975
    { 0x37, "asterisk" },
bellard authored
976
    { 0x39, "spc" },
bellard authored
977
    { 0x3a, "caps_lock" },
bellard authored
978
979
980
981
982
983
984
985
986
987
    { 0x3b, "f1" },
    { 0x3c, "f2" },
    { 0x3d, "f3" },
    { 0x3e, "f4" },
    { 0x3f, "f5" },
    { 0x40, "f6" },
    { 0x41, "f7" },
    { 0x42, "f8" },
    { 0x43, "f9" },
    { 0x44, "f10" },
bellard authored
988
    { 0x45, "num_lock" },
bellard authored
989
990
    { 0x46, "scroll_lock" },
991
992
    { 0xb5, "kp_divide" },
    { 0x37, "kp_multiply" },
993
    { 0x4a, "kp_subtract" },
994
995
996
    { 0x4e, "kp_add" },
    { 0x9c, "kp_enter" },
    { 0x53, "kp_decimal" },
997
    { 0x54, "sysrq" },
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008

    { 0x52, "kp_0" },
    { 0x4f, "kp_1" },
    { 0x50, "kp_2" },
    { 0x51, "kp_3" },
    { 0x4b, "kp_4" },
    { 0x4c, "kp_5" },
    { 0x4d, "kp_6" },
    { 0x47, "kp_7" },
    { 0x48, "kp_8" },
    { 0x49, "kp_9" },
1009
bellard authored
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
    { 0x56, "<" },

    { 0x57, "f11" },
    { 0x58, "f12" },

    { 0xb7, "print" },

    { 0xc7, "home" },
    { 0xc9, "pgup" },
    { 0xd1, "pgdn" },
    { 0xcf, "end" },

    { 0xcb, "left" },
    { 0xc8, "up" },
    { 0xd0, "down" },
    { 0xcd, "right" },

    { 0xd2, "insert" },
    { 0xd3, "delete" },
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
#if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
    { 0xf0, "stop" },
    { 0xf1, "again" },
    { 0xf2, "props" },
    { 0xf3, "undo" },
    { 0xf4, "front" },
    { 0xf5, "copy" },
    { 0xf6, "open" },
    { 0xf7, "paste" },
    { 0xf8, "find" },
    { 0xf9, "cut" },
    { 0xfa, "lf" },
    { 0xfb, "help" },
    { 0xfc, "meta_l" },
    { 0xfd, "meta_r" },
    { 0xfe, "compose" },
#endif
bellard authored
1046
1047
1048
1049
1050
1051
    { 0, NULL },
};

static int get_keycode(const char *key)
{
    const KeyDef *p;
1052
1053
    char *endp;
    int ret;
bellard authored
1054
1055
1056
1057
1058

    for(p = key_defs; p->name != NULL; p++) {
        if (!strcmp(key, p->name))
            return p->keycode;
    }
1059
1060
1061
1062
1063
    if (strstart(key, "0x", NULL)) {
        ret = strtoul(key, &endp, 0);
        if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
            return ret;
    }
bellard authored
1064
1065
1066
    return -1;
}
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
#define MAX_KEYCODES 16
static uint8_t keycodes[MAX_KEYCODES];
static int nb_pending_keycodes;
static QEMUTimer *key_timer;

static void release_keys(void *opaque)
{
    int keycode;

    while (nb_pending_keycodes > 0) {
        nb_pending_keycodes--;
        keycode = keycodes[nb_pending_keycodes];
        if (keycode & 0x80)
            kbd_put_keycode(0xe0);
        kbd_put_keycode(keycode | 0x80);
    }
}
1085
1086
static void do_sendkey(Monitor *mon, const char *string, int has_hold_time,
                       int hold_time)
bellard authored
1087
{
1088
1089
1090
1091
    char keyname_buf[16];
    char *separator;
    int keyname_len, keycode, i;
1092
1093
1094
1095
1096
1097
1098
    if (nb_pending_keycodes > 0) {
        qemu_del_timer(key_timer);
        release_keys(NULL);
    }
    if (!has_hold_time)
        hold_time = 100;
    i = 0;
1099
1100
1101
1102
1103
1104
    while (1) {
        separator = strchr(string, '-');
        keyname_len = separator ? separator - string : strlen(string);
        if (keyname_len > 0) {
            pstrcpy(keyname_buf, sizeof(keyname_buf), string);
            if (keyname_len > sizeof(keyname_buf) - 1) {
1105
                monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1106
                return;
bellard authored
1107
            }
1108
            if (i == MAX_KEYCODES) {
1109
                monitor_printf(mon, "too many keys\n");
1110
1111
1112
1113
1114
                return;
            }
            keyname_buf[keyname_len] = 0;
            keycode = get_keycode(keyname_buf);
            if (keycode < 0) {
1115
                monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1116
1117
                return;
            }
1118
            keycodes[i++] = keycode;
bellard authored
1119
        }
1120
        if (!separator)
bellard authored
1121
            break;
1122
        string = separator + 1;
bellard authored
1123
    }
1124
    nb_pending_keycodes = i;
bellard authored
1125
    /* key down events */
1126
    for (i = 0; i < nb_pending_keycodes; i++) {
bellard authored
1127
1128
1129
1130
1131
        keycode = keycodes[i];
        if (keycode & 0x80)
            kbd_put_keycode(0xe0);
        kbd_put_keycode(keycode & 0x7f);
    }
1132
    /* delayed key up events */
1133
1134
    qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
                    muldiv64(ticks_per_sec, hold_time, 1000));
bellard authored
1135
1136
}
bellard authored
1137
1138
static int mouse_button_state;
1139
static void do_mouse_move(Monitor *mon, const char *dx_str, const char *dy_str,
bellard authored
1140
1141
1142
1143
1144
1145
                          const char *dz_str)
{
    int dx, dy, dz;
    dx = strtol(dx_str, NULL, 0);
    dy = strtol(dy_str, NULL, 0);
    dz = 0;
1146
    if (dz_str)
bellard authored
1147
1148
1149
1150
        dz = strtol(dz_str, NULL, 0);
    kbd_mouse_event(dx, dy, dz, mouse_button_state);
}
1151
static void do_mouse_button(Monitor *mon, int button_state)
bellard authored
1152
1153
1154
1155
1156
{
    mouse_button_state = button_state;
    kbd_mouse_event(0, 0, 0, mouse_button_state);
}
1157
1158
static void do_ioport_read(Monitor *mon, int count, int format, int size,
                           int addr, int has_index, int index)
bellard authored
1159
1160
1161
1162
1163
{
    uint32_t val;
    int suffix;

    if (has_index) {
1164
        cpu_outb(NULL, addr & IOPORTS_MASK, index & 0xff);
bellard authored
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
        addr++;
    }
    addr &= 0xffff;

    switch(size) {
    default:
    case 1:
        val = cpu_inb(NULL, addr);
        suffix = 'b';
        break;
    case 2:
        val = cpu_inw(NULL, addr);
        suffix = 'w';
        break;
    case 4:
        val = cpu_inl(NULL, addr);
        suffix = 'l';
        break;
    }
1184
1185
    monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
                   suffix, addr, size * 2, val);
bellard authored
1186
}
bellard authored
1187
1188
static void do_boot_set(Monitor *mon, const char *bootdevice)
1189
1190
1191
{
    int res;
1192
1193
1194
1195
1196
    res = qemu_boot_set(bootdevice);
    if (res == 0) {
        monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
    } else if (res > 0) {
        monitor_printf(mon, "setting boot device list failed\n");
1197
    } else {
1198
1199
        monitor_printf(mon, "no function defined to set boot device list for "
                       "this architecture\n");
1200
1201
1202
    }
}
1203
static void do_system_reset(Monitor *mon)
bellard authored
1204
1205
1206
1207
{
    qemu_system_reset_request();
}
1208
static void do_system_powerdown(Monitor *mon)
bellard authored
1209
1210
1211
1212
{
    qemu_system_powerdown_request();
}
bellard authored
1213
#if defined(TARGET_I386)
1214
static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
bellard authored
1215
{
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
    monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
                   addr,
                   pte & mask,
                   pte & PG_GLOBAL_MASK ? 'G' : '-',
                   pte & PG_PSE_MASK ? 'P' : '-',
                   pte & PG_DIRTY_MASK ? 'D' : '-',
                   pte & PG_ACCESSED_MASK ? 'A' : '-',
                   pte & PG_PCD_MASK ? 'C' : '-',
                   pte & PG_PWT_MASK ? 'T' : '-',
                   pte & PG_USER_MASK ? 'U' : '-',
                   pte & PG_RW_MASK ? 'W' : '-');
bellard authored
1227
1228
}
1229
static void tlb_info(Monitor *mon)
bellard authored
1230
{
bellard authored
1231
    CPUState *env;
bellard authored
1232
1233
1234
    int l1, l2;
    uint32_t pgd, pde, pte;
bellard authored
1235
1236
1237
1238
    env = mon_get_cpu();
    if (!env)
        return;
bellard authored
1239
    if (!(env->cr[0] & CR0_PG_MASK)) {
1240
        monitor_printf(mon, "PG disabled\n");
bellard authored
1241
1242
1243
1244
1245
1246
1247
1248
        return;
    }
    pgd = env->cr[3] & ~0xfff;
    for(l1 = 0; l1 < 1024; l1++) {
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
        pde = le32_to_cpu(pde);
        if (pde & PG_PRESENT_MASK) {
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1249
                print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
bellard authored
1250
1251
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1252
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
bellard authored
1253
1254
1255
                                             (uint8_t *)&pte, 4);
                    pte = le32_to_cpu(pte);
                    if (pte & PG_PRESENT_MASK) {
1256
                        print_pte(mon, (l1 << 22) + (l2 << 12),
1257
                                  pte & ~PG_PSE_MASK,
bellard authored
1258
1259
1260
1261
1262
1263
1264
1265
                                  ~0xfff);
                    }
                }
            }
        }
    }
}
1266
static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
bellard authored
1267
1268
                      uint32_t end, int prot)
{
1269
1270
1271
    int prot1;
    prot1 = *plast_prot;
    if (prot != prot1) {
bellard authored
1272
        if (*pstart != -1) {
1273
1274
1275
1276
1277
            monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
                           *pstart, end, end - *pstart,
                           prot1 & PG_USER_MASK ? 'u' : '-',
                           'r',
                           prot1 & PG_RW_MASK ? 'w' : '-');
bellard authored
1278
1279
1280
1281
1282
1283
1284
1285
1286
        }
        if (prot != 0)
            *pstart = end;
        else
            *pstart = -1;
        *plast_prot = prot;
    }
}
1287
static void mem_info(Monitor *mon)
bellard authored
1288
{
bellard authored
1289
    CPUState *env;
bellard authored
1290
1291
1292
    int l1, l2, prot, last_prot;
    uint32_t pgd, pde, pte, start, end;
bellard authored
1293
1294
1295
1296
    env = mon_get_cpu();
    if (!env)
        return;
bellard authored
1297
    if (!(env->cr[0] & CR0_PG_MASK)) {
1298
        monitor_printf(mon, "PG disabled\n");
bellard authored
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
        return;
    }
    pgd = env->cr[3] & ~0xfff;
    last_prot = 0;
    start = -1;
    for(l1 = 0; l1 < 1024; l1++) {
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
        pde = le32_to_cpu(pde);
        end = l1 << 22;
        if (pde & PG_PRESENT_MASK) {
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
                prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1311
                mem_print(mon, &start, &last_prot, end, prot);
bellard authored
1312
1313
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1314
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
bellard authored
1315
1316
1317
1318
1319
1320
1321
1322
                                             (uint8_t *)&pte, 4);
                    pte = le32_to_cpu(pte);
                    end = (l1 << 22) + (l2 << 12);
                    if (pte & PG_PRESENT_MASK) {
                        prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
                    } else {
                        prot = 0;
                    }
1323
                    mem_print(mon, &start, &last_prot, end, prot);
bellard authored
1324
1325
1326
1327
                }
            }
        } else {
            prot = 0;
1328
            mem_print(mon, &start, &last_prot, end, prot);
bellard authored
1329
1330
1331
1332
1333
        }
    }
}
#endif
1334
1335
#if defined(TARGET_SH4)
1336
static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
1337
{
1338
1339
1340
1341
1342
1343
1344
1345
    monitor_printf(mon, " tlb%i:\t"
                   "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
                   "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
                   "dirty=%hhu writethrough=%hhu\n",
                   idx,
                   tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
                   tlb->v, tlb->sh, tlb->c, tlb->pr,
                   tlb->d, tlb->wt);
1346
1347
}
1348
static void tlb_info(Monitor *mon)
1349
1350
1351
1352
{
    CPUState *env = mon_get_cpu();
    int i;
1353
    monitor_printf (mon, "ITLB:\n");
1354
    for (i = 0 ; i < ITLB_SIZE ; i++)
1355
1356
        print_tlb (mon, i, &env->itlb[i]);
    monitor_printf (mon, "UTLB:\n");
1357
    for (i = 0 ; i < UTLB_SIZE ; i++)
1358
        print_tlb (mon, i, &env->utlb[i]);
1359
1360
1361
1362
}

#endif
1363
static void do_info_kqemu(Monitor *mon)
bellard authored
1364
{
1365
#ifdef CONFIG_KQEMU
bellard authored
1366
    CPUState *env;
bellard authored
1367
1368
    int val;
    val = 0;
bellard authored
1369
1370
    env = mon_get_cpu();
    if (!env) {
1371
        monitor_printf(mon, "No cpu initialized yet");
bellard authored
1372
1373
1374
        return;
    }
    val = env->kqemu_enabled;
1375
    monitor_printf(mon, "kqemu support: ");
bellard authored
1376
1377
1378
    switch(val) {
    default:
    case 0:
1379
        monitor_printf(mon, "disabled\n");
bellard authored
1380
1381
        break;
    case 1:
1382
        monitor_printf(mon, "enabled for user code\n");
bellard authored
1383
1384
        break;
    case 2:
1385
        monitor_printf(mon, "enabled for user and kernel code\n");
bellard authored
1386
1387
        break;
    }
bellard authored
1388
#else
1389
    monitor_printf(mon, "kqemu support: not compiled\n");
bellard authored
1390
#endif
1391
}
bellard authored
1392
1393
static void do_info_kvm(Monitor *mon)
aliguori authored
1394
1395
{
#ifdef CONFIG_KVM
1396
    monitor_printf(mon, "kvm support: ");
aliguori authored
1397
    if (kvm_enabled())
1398
        monitor_printf(mon, "enabled\n");
aliguori authored
1399
    else
1400
        monitor_printf(mon, "disabled\n");
aliguori authored
1401
#else
1402
    monitor_printf(mon, "kvm support: not compiled\n");
aliguori authored
1403
1404
1405
#endif
}
1406
1407
static void do_info_numa(Monitor *mon)
{
1408
    int i;
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
    CPUState *env;

    monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
    for (i = 0; i < nb_numa_nodes; i++) {
        monitor_printf(mon, "node %d cpus:", i);
        for (env = first_cpu; env != NULL; env = env->next_cpu) {
            if (env->numa_node == i) {
                monitor_printf(mon, " %d", env->cpu_index);
            }
        }
        monitor_printf(mon, "\n");
        monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
            node_mem[i] >> 20);
    }
}
bellard authored
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
#ifdef CONFIG_PROFILER

int64_t kqemu_time;
int64_t qemu_time;
int64_t kqemu_exec_count;
int64_t dev_time;
int64_t kqemu_ret_int_count;
int64_t kqemu_ret_excp_count;
int64_t kqemu_ret_intr_count;
1435
static void do_info_profile(Monitor *mon)
bellard authored
1436
1437
1438
1439
1440
{
    int64_t total;
    total = qemu_time;
    if (total == 0)
        total = 1;
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
    monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
                   dev_time, dev_time / (double)ticks_per_sec);
    monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
                   qemu_time, qemu_time / (double)ticks_per_sec);
    monitor_printf(mon, "kqemu time  %" PRId64 " (%0.3f %0.1f%%) count=%"
                        PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%"
                        PRId64 "\n",
                   kqemu_time, kqemu_time / (double)ticks_per_sec,
                   kqemu_time / (double)total * 100.0,
                   kqemu_exec_count,
                   kqemu_ret_int_count,
                   kqemu_ret_excp_count,
                   kqemu_ret_intr_count);
bellard authored
1454
1455
1456
1457
1458
1459
1460
    qemu_time = 0;
    kqemu_time = 0;
    kqemu_exec_count = 0;
    dev_time = 0;
    kqemu_ret_int_count = 0;
    kqemu_ret_excp_count = 0;
    kqemu_ret_intr_count = 0;
1461
#ifdef CONFIG_KQEMU
bellard authored
1462
1463
1464
1465
    kqemu_record_dump();
#endif
}
#else
1466
static void do_info_profile(Monitor *mon)
bellard authored
1467
{
1468
    monitor_printf(mon, "Internal profiler not compiled\n");
bellard authored
1469
1470
1471
}
#endif
1472
1473
1474
/* Capture support */
static LIST_HEAD (capture_list_head, CaptureState) capture_head;
1475
static void do_info_capture(Monitor *mon)
1476
1477
1478
1479
1480
{
    int i;
    CaptureState *s;

    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1481
        monitor_printf(mon, "[%d]: ", i);
1482
1483
1484
1485
        s->ops.info (s->opaque);
    }
}
1486
#ifdef HAS_AUDIO
1487
static void do_stop_capture(Monitor *mon, int n)
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
{
    int i;
    CaptureState *s;

    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
        if (i == n) {
            s->ops.destroy (s->opaque);
            LIST_REMOVE (s, entries);
            qemu_free (s);
            return;
        }
    }
}
1502
1503
1504
1505
static void do_wav_capture(Monitor *mon, const char *path,
                           int has_freq, int freq,
                           int has_bits, int bits,
                           int has_channels, int nchannels)
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
{
    CaptureState *s;

    s = qemu_mallocz (sizeof (*s));

    freq = has_freq ? freq : 44100;
    bits = has_bits ? bits : 16;
    nchannels = has_channels ? nchannels : 2;

    if (wav_start_capture (s, path, freq, bits, nchannels)) {
1516
        monitor_printf(mon, "Faied to add wave capture\n");
1517
1518
1519
1520
1521
1522
        qemu_free (s);
    }
    LIST_INSERT_HEAD (&capture_head, s, entries);
}
#endif
1523
#if defined(TARGET_I386)
1524
static void do_inject_nmi(Monitor *mon, int cpu_index)
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
{
    CPUState *env;

    for (env = first_cpu; env != NULL; env = env->next_cpu)
        if (env->cpu_index == cpu_index) {
            cpu_interrupt(env, CPU_INTERRUPT_NMI);
            break;
        }
}
#endif
1536
static void do_info_status(Monitor *mon)
aurel32 authored
1537
{
1538
1539
1540
1541
1542
1543
1544
    if (vm_running) {
        if (singlestep) {
            monitor_printf(mon, "VM status: running (single step mode)\n");
        } else {
            monitor_printf(mon, "VM status: running\n");
        }
    } else
1545
       monitor_printf(mon, "VM status: paused\n");
aurel32 authored
1546
1547
1548
}
1549
static void do_balloon(Monitor *mon, int value)
1550
1551
1552
1553
1554
{
    ram_addr_t target = value;
    qemu_balloon(target << 20);
}
1555
static void do_info_balloon(Monitor *mon)
1556
1557
1558
1559
{
    ram_addr_t actual;

    actual = qemu_balloon_status();
aliguori authored
1560
    if (kvm_enabled() && !kvm_has_sync_mmu())
1561
1562
        monitor_printf(mon, "Using KVM without synchronous MMU, "
                       "ballooning disabled\n");
aliguori authored
1563
    else if (actual == 0)
1564
        monitor_printf(mon, "Ballooning not activated in VM\n");
1565
    else
1566
        monitor_printf(mon, "balloon: actual=%d\n", (int)(actual >> 20));
1567
1568
}
1569
static qemu_acl *find_acl(Monitor *mon, const char *name)
1570
{
1571
    qemu_acl *acl = qemu_acl_find(name);
1572
1573

    if (!acl) {
1574
        monitor_printf(mon, "acl: unknown list '%s'\n", name);
1575
    }
1576
1577
1578
1579
1580
1581
1582
1583
    return acl;
}

static void do_acl_show(Monitor *mon, const char *aclname)
{
    qemu_acl *acl = find_acl(mon, aclname);
    qemu_acl_entry *entry;
    int i = 0;
1584
1585
    if (acl) {
1586
        monitor_printf(mon, "policy: %s\n",
1587
                       acl->defaultDeny ? "deny" : "allow");
1588
1589
1590
        TAILQ_FOREACH(entry, &acl->entries, next) {
            i++;
            monitor_printf(mon, "%d: %s %s\n", i,
1591
                           entry->deny ? "deny" : "allow", entry->match);
1592
        }
1593
1594
1595
1596
1597
1598
1599
1600
    }
}

static void do_acl_reset(Monitor *mon, const char *aclname)
{
    qemu_acl *acl = find_acl(mon, aclname);

    if (acl) {
1601
1602
        qemu_acl_reset(acl);
        monitor_printf(mon, "acl: removed all rules\n");
1603
1604
1605
1606
1607
1608
1609
    }
}

static void do_acl_policy(Monitor *mon, const char *aclname,
                          const char *policy)
{
    qemu_acl *acl = find_acl(mon, aclname);
1610
1611
1612
    if (acl) {
        if (strcmp(policy, "allow") == 0) {
1613
1614
            acl->defaultDeny = 0;
            monitor_printf(mon, "acl: policy set to 'allow'\n");
1615
        } else if (strcmp(policy, "deny") == 0) {
1616
1617
1618
            acl->defaultDeny = 1;
            monitor_printf(mon, "acl: policy set to 'deny'\n");
        } else {
1619
1620
            monitor_printf(mon, "acl: unknown policy '%s', "
                           "expected 'deny' or 'allow'\n", policy);
1621
        }
1622
1623
    }
}
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
static void do_acl_add(Monitor *mon, const char *aclname,
                       const char *match, const char *policy,
                       int has_index, int index)
{
    qemu_acl *acl = find_acl(mon, aclname);
    int deny, ret;

    if (acl) {
        if (strcmp(policy, "allow") == 0) {
            deny = 0;
        } else if (strcmp(policy, "deny") == 0) {
            deny = 1;
        } else {
            monitor_printf(mon, "acl: unknown policy '%s', "
                           "expected 'deny' or 'allow'\n", policy);
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
            return;
        }
        if (has_index)
            ret = qemu_acl_insert(acl, deny, match, index);
        else
            ret = qemu_acl_append(acl, deny, match);
        if (ret < 0)
            monitor_printf(mon, "acl: unable to add acl entry\n");
        else
            monitor_printf(mon, "acl: added rule at position %d\n", ret);
1650
1651
    }
}
1652
1653
1654
1655
1656
static void do_acl_remove(Monitor *mon, const char *aclname, const char *match)
{
    qemu_acl *acl = find_acl(mon, aclname);
    int ret;
1657
1658
    if (acl) {
1659
1660
1661
1662
1663
        ret = qemu_acl_remove(acl, match);
        if (ret < 0)
            monitor_printf(mon, "acl: no matching acl entry\n");
        else
            monitor_printf(mon, "acl: removed rule at position %d\n", ret);
1664
1665
1666
    }
}
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
#if defined(TARGET_I386)
static void do_inject_mce(Monitor *mon,
                          int cpu_index, int bank,
                          unsigned status_hi, unsigned status_lo,
                          unsigned mcg_status_hi, unsigned mcg_status_lo,
                          unsigned addr_hi, unsigned addr_lo,
                          unsigned misc_hi, unsigned misc_lo)
{
    CPUState *cenv;
    uint64_t status = ((uint64_t)status_hi << 32) | status_lo;
    uint64_t mcg_status = ((uint64_t)mcg_status_hi << 32) | mcg_status_lo;
    uint64_t addr = ((uint64_t)addr_hi << 32) | addr_lo;
    uint64_t misc = ((uint64_t)misc_hi << 32) | misc_lo;

    for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
        if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
            cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
            break;
        }
}
#endif
1689
static const mon_cmd_t mon_cmds[] = {
1690
#include "qemu-monitor.h"
1691
    { NULL, NULL, },
bellard authored
1692
1693
};
1694
/* Please update qemu-monitor.hx when adding or changing commands */
1695
static const mon_cmd_t info_cmds[] = {
bellard authored
1696
    { "version", "", do_info_version,
blueswir1 authored
1697
      "", "show the version of QEMU" },
1698
    { "network", "", do_info_network,
bellard authored
1699
      "", "show the network state" },
1700
1701
    { "chardev", "", qemu_chr_info,
      "", "show the character devices" },
1702
    { "block", "", bdrv_info,
bellard authored
1703
      "", "show the block devices" },
1704
    { "blockstats", "", bdrv_info_stats,
1705
      "", "show block device statistics" },
1706
1707
    { "registers", "", do_info_registers,
      "", "show the cpu registers" },
bellard authored
1708
1709
    { "cpus", "", do_info_cpus,
      "", "show infos for each CPU" },
1710
1711
    { "history", "", do_info_history,
      "", "show the command line history", },
1712
1713
    { "irq", "", irq_info,
      "", "show the interrupts statistics (if available)", },
1714
1715
    { "pic", "", pic_info,
      "", "show i8259 (PIC) state", },
bellard authored
1716
1717
    { "pci", "", pci_info,
      "", "show PCI info", },
1718
#if defined(TARGET_I386) || defined(TARGET_SH4)
bellard authored
1719
1720
    { "tlb", "", tlb_info,
      "", "show virtual to physical memory mappings", },
1721
1722
#endif
#if defined(TARGET_I386)
bellard authored
1723
1724
    { "mem", "", mem_info,
      "", "show the active virtual memory mappings", },
1725
1726
    { "hpet", "", do_info_hpet,
      "", "show state of HPET", },
bellard authored
1727
#endif
bellard authored
1728
1729
    { "jit", "", do_info_jit,
      "", "show dynamic compiler info", },
bellard authored
1730
    { "kqemu", "", do_info_kqemu,
blueswir1 authored
1731
      "", "show KQEMU information", },
aliguori authored
1732
    { "kvm", "", do_info_kvm,
blueswir1 authored
1733
      "", "show KVM information", },
1734
1735
    { "numa", "", do_info_numa,
      "", "show NUMA information", },
bellard authored
1736
1737
1738
1739
    { "usb", "", usb_info,
      "", "show guest USB devices", },
    { "usbhost", "", usb_host_info,
      "", "show host USB devices", },
bellard authored
1740
1741
    { "profile", "", do_info_profile,
      "", "show profiling information", },
1742
    { "capture", "", do_info_capture,
bellard authored
1743
      "", "show capture information" },
bellard authored
1744
    { "snapshots", "", do_info_snapshots,
bellard authored
1745
      "", "show the currently saved VM snapshots" },
aurel32 authored
1746
1747
    { "status", "", do_info_status,
      "", "show the current VM status (running|paused)" },
1748
1749
    { "pcmcia", "", pcmcia_info,
      "", "show guest PCMCIA status" },
1750
1751
    { "mice", "", do_info_mice,
      "", "show which guest mouse is receiving events" },
1752
1753
    { "vnc", "", do_info_vnc,
      "", "show the vnc server status"},
1754
1755
    { "name", "", do_info_name,
      "", "show the current VM name" },
1756
1757
    { "uuid", "", do_info_uuid,
      "", "show the current VM UUID" },
1758
1759
1760
1761
#if defined(TARGET_PPC)
    { "cpustats", "", do_info_cpu_stats,
      "", "show CPU statistics", },
#endif
1762
#if defined(CONFIG_SLIRP)
1763
1764
    { "usernet", "", do_info_usernet,
      "", "show user network stack connection states", },
1765
#endif
1766
    { "migrate", "", do_info_migrate, "", "show migration status" },
1767
1768
    { "balloon", "", do_info_balloon,
      "", "show balloon information" },
1769
1770
    { "qtree", "", do_info_qtree,
      "", "show device tree" },
bellard authored
1771
1772
1773
    { NULL, NULL, },
};
1774
1775
1776
1777
1778
/*******************************************************************/

static const char *pch;
static jmp_buf expr_env;
bellard authored
1779
1780
1781
#define MD_TLONG 0
#define MD_I32   1
1782
1783
1784
typedef struct MonitorDef {
    const char *name;
    int offset;
1785
    target_long (*get_value)(const struct MonitorDef *md, int val);
bellard authored
1786
    int type;
1787
1788
} MonitorDef;
1789
#if defined(TARGET_I386)
1790
static target_long monitor_get_pc (const struct MonitorDef *md, int val)
1791
{
bellard authored
1792
1793
1794
1795
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return env->eip + env->segs[R_CS].base;
1796
1797
1798
}
#endif
1799
#if defined(TARGET_PPC)
1800
static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
1801
{
bellard authored
1802
    CPUState *env = mon_get_cpu();
1803
1804
1805
    unsigned int u;
    int i;
bellard authored
1806
1807
1808
    if (!env)
        return 0;
1809
1810
    u = 0;
    for (i = 0; i < 8; i++)
1811
        u |= env->crf[i] << (32 - (4 * i));
1812
1813
1814
1815

    return u;
}
1816
static target_long monitor_get_msr (const struct MonitorDef *md, int val)
1817
{
bellard authored
1818
1819
1820
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
1821
    return env->msr;
1822
1823
}
1824
static target_long monitor_get_xer (const struct MonitorDef *md, int val)
1825
{
bellard authored
1826
1827
1828
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
1829
    return env->xer;
1830
}
1831
1832
static target_long monitor_get_decr (const struct MonitorDef *md, int val)
1833
{
bellard authored
1834
1835
1836
1837
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_decr(env);
1838
1839
}
1840
static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
1841
{
bellard authored
1842
1843
1844
1845
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_tbu(env);
1846
1847
}
1848
static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
1849
{
bellard authored
1850
1851
1852
1853
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return cpu_ppc_load_tbl(env);
1854
}
1855
1856
#endif
1857
#if defined(TARGET_SPARC)
bellard authored
1858
#ifndef TARGET_SPARC64
1859
static target_long monitor_get_psr (const struct MonitorDef *md, int val)
1860
{
bellard authored
1861
1862
1863
1864
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return GET_PSR(env);
1865
}
bellard authored
1866
#endif
1867
1868
static target_long monitor_get_reg(const struct MonitorDef *md, int val)
1869
{
bellard authored
1870
1871
1872
1873
    CPUState *env = mon_get_cpu();
    if (!env)
        return 0;
    return env->regwptr[val];
1874
1875
1876
}
#endif
1877
static const MonitorDef monitor_defs[] = {
1878
#ifdef TARGET_I386
1879
1880

#define SEG(name, seg) \
bellard authored
1881
    { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
1882
    { name ".base", offsetof(CPUState, segs[seg].base) },\
bellard authored
1883
    { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
1884
1885
1886
1887
1888
1889
1890
1891
    { "eax", offsetof(CPUState, regs[0]) },
    { "ecx", offsetof(CPUState, regs[1]) },
    { "edx", offsetof(CPUState, regs[2]) },
    { "ebx", offsetof(CPUState, regs[3]) },
    { "esp|sp", offsetof(CPUState, regs[4]) },
    { "ebp|fp", offsetof(CPUState, regs[5]) },
    { "esi", offsetof(CPUState, regs[6]) },
bellard authored
1892
    { "edi", offsetof(CPUState, regs[7]) },
bellard authored
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
#ifdef TARGET_X86_64
    { "r8", offsetof(CPUState, regs[8]) },
    { "r9", offsetof(CPUState, regs[9]) },
    { "r10", offsetof(CPUState, regs[10]) },
    { "r11", offsetof(CPUState, regs[11]) },
    { "r12", offsetof(CPUState, regs[12]) },
    { "r13", offsetof(CPUState, regs[13]) },
    { "r14", offsetof(CPUState, regs[14]) },
    { "r15", offsetof(CPUState, regs[15]) },
#endif
1903
    { "eflags", offsetof(CPUState, eflags) },
1904
1905
1906
1907
    { "eip", offsetof(CPUState, eip) },
    SEG("cs", R_CS)
    SEG("ds", R_DS)
    SEG("es", R_ES)
bellard authored
1908
    SEG("ss", R_SS)
1909
1910
1911
    SEG("fs", R_FS)
    SEG("gs", R_GS)
    { "pc", 0, monitor_get_pc, },
1912
#elif defined(TARGET_PPC)
1913
    /* General purpose registers */
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
    { "r0", offsetof(CPUState, gpr[0]) },
    { "r1", offsetof(CPUState, gpr[1]) },
    { "r2", offsetof(CPUState, gpr[2]) },
    { "r3", offsetof(CPUState, gpr[3]) },
    { "r4", offsetof(CPUState, gpr[4]) },
    { "r5", offsetof(CPUState, gpr[5]) },
    { "r6", offsetof(CPUState, gpr[6]) },
    { "r7", offsetof(CPUState, gpr[7]) },
    { "r8", offsetof(CPUState, gpr[8]) },
    { "r9", offsetof(CPUState, gpr[9]) },
    { "r10", offsetof(CPUState, gpr[10]) },
    { "r11", offsetof(CPUState, gpr[11]) },
    { "r12", offsetof(CPUState, gpr[12]) },
    { "r13", offsetof(CPUState, gpr[13]) },
    { "r14", offsetof(CPUState, gpr[14]) },
    { "r15", offsetof(CPUState, gpr[15]) },
    { "r16", offsetof(CPUState, gpr[16]) },
    { "r17", offsetof(CPUState, gpr[17]) },
    { "r18", offsetof(CPUState, gpr[18]) },
    { "r19", offsetof(CPUState, gpr[19]) },
    { "r20", offsetof(CPUState, gpr[20]) },
    { "r21", offsetof(CPUState, gpr[21]) },
    { "r22", offsetof(CPUState, gpr[22]) },
    { "r23", offsetof(CPUState, gpr[23]) },
    { "r24", offsetof(CPUState, gpr[24]) },
    { "r25", offsetof(CPUState, gpr[25]) },
    { "r26", offsetof(CPUState, gpr[26]) },
    { "r27", offsetof(CPUState, gpr[27]) },
    { "r28", offsetof(CPUState, gpr[28]) },
    { "r29", offsetof(CPUState, gpr[29]) },
    { "r30", offsetof(CPUState, gpr[30]) },
    { "r31", offsetof(CPUState, gpr[31]) },
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
    /* Floating point registers */
    { "f0", offsetof(CPUState, fpr[0]) },
    { "f1", offsetof(CPUState, fpr[1]) },
    { "f2", offsetof(CPUState, fpr[2]) },
    { "f3", offsetof(CPUState, fpr[3]) },
    { "f4", offsetof(CPUState, fpr[4]) },
    { "f5", offsetof(CPUState, fpr[5]) },
    { "f6", offsetof(CPUState, fpr[6]) },
    { "f7", offsetof(CPUState, fpr[7]) },
    { "f8", offsetof(CPUState, fpr[8]) },
    { "f9", offsetof(CPUState, fpr[9]) },
    { "f10", offsetof(CPUState, fpr[10]) },
    { "f11", offsetof(CPUState, fpr[11]) },
    { "f12", offsetof(CPUState, fpr[12]) },
    { "f13", offsetof(CPUState, fpr[13]) },
    { "f14", offsetof(CPUState, fpr[14]) },
    { "f15", offsetof(CPUState, fpr[15]) },
    { "f16", offsetof(CPUState, fpr[16]) },
    { "f17", offsetof(CPUState, fpr[17]) },
    { "f18", offsetof(CPUState, fpr[18]) },
    { "f19", offsetof(CPUState, fpr[19]) },
    { "f20", offsetof(CPUState, fpr[20]) },
    { "f21", offsetof(CPUState, fpr[21]) },
    { "f22", offsetof(CPUState, fpr[22]) },
    { "f23", offsetof(CPUState, fpr[23]) },
    { "f24", offsetof(CPUState, fpr[24]) },
    { "f25", offsetof(CPUState, fpr[25]) },
    { "f26", offsetof(CPUState, fpr[26]) },
    { "f27", offsetof(CPUState, fpr[27]) },
    { "f28", offsetof(CPUState, fpr[28]) },
    { "f29", offsetof(CPUState, fpr[29]) },
    { "f30", offsetof(CPUState, fpr[30]) },
    { "f31", offsetof(CPUState, fpr[31]) },
    { "fpscr", offsetof(CPUState, fpscr) },
    /* Next instruction pointer */
1981
    { "nip|pc", offsetof(CPUState, nip) },
1982
1983
    { "lr", offsetof(CPUState, lr) },
    { "ctr", offsetof(CPUState, ctr) },
1984
    { "decr", 0, &monitor_get_decr, },
1985
    { "ccr", 0, &monitor_get_ccr, },
1986
    /* Machine state register */
1987
1988
    { "msr", 0, &monitor_get_msr, },
    { "xer", 0, &monitor_get_xer, },
1989
1990
    { "tbu", 0, &monitor_get_tbu, },
    { "tbl", 0, &monitor_get_tbl, },
1991
1992
1993
1994
1995
#if defined(TARGET_PPC64)
    /* Address space register */
    { "asr", offsetof(CPUState, asr) },
#endif
    /* Segment registers */
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
    { "sdr1", offsetof(CPUState, sdr1) },
    { "sr0", offsetof(CPUState, sr[0]) },
    { "sr1", offsetof(CPUState, sr[1]) },
    { "sr2", offsetof(CPUState, sr[2]) },
    { "sr3", offsetof(CPUState, sr[3]) },
    { "sr4", offsetof(CPUState, sr[4]) },
    { "sr5", offsetof(CPUState, sr[5]) },
    { "sr6", offsetof(CPUState, sr[6]) },
    { "sr7", offsetof(CPUState, sr[7]) },
    { "sr8", offsetof(CPUState, sr[8]) },
    { "sr9", offsetof(CPUState, sr[9]) },
    { "sr10", offsetof(CPUState, sr[10]) },
    { "sr11", offsetof(CPUState, sr[11]) },
    { "sr12", offsetof(CPUState, sr[12]) },
    { "sr13", offsetof(CPUState, sr[13]) },
    { "sr14", offsetof(CPUState, sr[14]) },
    { "sr15", offsetof(CPUState, sr[15]) },
    /* Too lazy to put BATs and SPRs ... */
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
#elif defined(TARGET_SPARC)
    { "g0", offsetof(CPUState, gregs[0]) },
    { "g1", offsetof(CPUState, gregs[1]) },
    { "g2", offsetof(CPUState, gregs[2]) },
    { "g3", offsetof(CPUState, gregs[3]) },
    { "g4", offsetof(CPUState, gregs[4]) },
    { "g5", offsetof(CPUState, gregs[5]) },
    { "g6", offsetof(CPUState, gregs[6]) },
    { "g7", offsetof(CPUState, gregs[7]) },
    { "o0", 0, monitor_get_reg },
    { "o1", 1, monitor_get_reg },
    { "o2", 2, monitor_get_reg },
    { "o3", 3, monitor_get_reg },
    { "o4", 4, monitor_get_reg },
    { "o5", 5, monitor_get_reg },
    { "o6", 6, monitor_get_reg },
    { "o7", 7, monitor_get_reg },
    { "l0", 8, monitor_get_reg },
    { "l1", 9, monitor_get_reg },
    { "l2", 10, monitor_get_reg },
    { "l3", 11, monitor_get_reg },
    { "l4", 12, monitor_get_reg },
    { "l5", 13, monitor_get_reg },
    { "l6", 14, monitor_get_reg },
    { "l7", 15, monitor_get_reg },
    { "i0", 16, monitor_get_reg },
    { "i1", 17, monitor_get_reg },
    { "i2", 18, monitor_get_reg },
    { "i3", 19, monitor_get_reg },
    { "i4", 20, monitor_get_reg },
    { "i5", 21, monitor_get_reg },
    { "i6", 22, monitor_get_reg },
    { "i7", 23, monitor_get_reg },
    { "pc", offsetof(CPUState, pc) },
    { "npc", offsetof(CPUState, npc) },
    { "y", offsetof(CPUState, y) },
bellard authored
2050
#ifndef TARGET_SPARC64
2051
2052
    { "psr", 0, &monitor_get_psr, },
    { "wim", offsetof(CPUState, wim) },
bellard authored
2053
#endif
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
    { "tbr", offsetof(CPUState, tbr) },
    { "fsr", offsetof(CPUState, fsr) },
    { "f0", offsetof(CPUState, fpr[0]) },
    { "f1", offsetof(CPUState, fpr[1]) },
    { "f2", offsetof(CPUState, fpr[2]) },
    { "f3", offsetof(CPUState, fpr[3]) },
    { "f4", offsetof(CPUState, fpr[4]) },
    { "f5", offsetof(CPUState, fpr[5]) },
    { "f6", offsetof(CPUState, fpr[6]) },
    { "f7", offsetof(CPUState, fpr[7]) },
    { "f8", offsetof(CPUState, fpr[8]) },
    { "f9", offsetof(CPUState, fpr[9]) },
    { "f10", offsetof(CPUState, fpr[10]) },
    { "f11", offsetof(CPUState, fpr[11]) },
    { "f12", offsetof(CPUState, fpr[12]) },
    { "f13", offsetof(CPUState, fpr[13]) },
    { "f14", offsetof(CPUState, fpr[14]) },
    { "f15", offsetof(CPUState, fpr[15]) },
    { "f16", offsetof(CPUState, fpr[16]) },
    { "f17", offsetof(CPUState, fpr[17]) },
    { "f18", offsetof(CPUState, fpr[18]) },
    { "f19", offsetof(CPUState, fpr[19]) },
    { "f20", offsetof(CPUState, fpr[20]) },
    { "f21", offsetof(CPUState, fpr[21]) },
    { "f22", offsetof(CPUState, fpr[22]) },
    { "f23", offsetof(CPUState, fpr[23]) },
    { "f24", offsetof(CPUState, fpr[24]) },
    { "f25", offsetof(CPUState, fpr[25]) },
    { "f26", offsetof(CPUState, fpr[26]) },
    { "f27", offsetof(CPUState, fpr[27]) },
    { "f28", offsetof(CPUState, fpr[28]) },
    { "f29", offsetof(CPUState, fpr[29]) },
    { "f30", offsetof(CPUState, fpr[30]) },
    { "f31", offsetof(CPUState, fpr[31]) },
bellard authored
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
#ifdef TARGET_SPARC64
    { "f32", offsetof(CPUState, fpr[32]) },
    { "f34", offsetof(CPUState, fpr[34]) },
    { "f36", offsetof(CPUState, fpr[36]) },
    { "f38", offsetof(CPUState, fpr[38]) },
    { "f40", offsetof(CPUState, fpr[40]) },
    { "f42", offsetof(CPUState, fpr[42]) },
    { "f44", offsetof(CPUState, fpr[44]) },
    { "f46", offsetof(CPUState, fpr[46]) },
    { "f48", offsetof(CPUState, fpr[48]) },
    { "f50", offsetof(CPUState, fpr[50]) },
    { "f52", offsetof(CPUState, fpr[52]) },
    { "f54", offsetof(CPUState, fpr[54]) },
    { "f56", offsetof(CPUState, fpr[56]) },
    { "f58", offsetof(CPUState, fpr[58]) },
    { "f60", offsetof(CPUState, fpr[60]) },
    { "f62", offsetof(CPUState, fpr[62]) },
    { "asi", offsetof(CPUState, asi) },
    { "pstate", offsetof(CPUState, pstate) },
    { "cansave", offsetof(CPUState, cansave) },
    { "canrestore", offsetof(CPUState, canrestore) },
    { "otherwin", offsetof(CPUState, otherwin) },
    { "wstate", offsetof(CPUState, wstate) },
    { "cleanwin", offsetof(CPUState, cleanwin) },
    { "fprs", offsetof(CPUState, fprs) },
#endif
2114
2115
2116
2117
#endif
    { NULL },
};
2118
static void expr_error(Monitor *mon, const char *msg)
bellard authored
2119
{
2120
    monitor_printf(mon, "%s\n", msg);
2121
2122
2123
    longjmp(expr_env, 1);
}
bellard authored
2124
/* return 0 if OK, -1 if not found, -2 if no CPU defined */
bellard authored
2125
static int get_monitor_def(target_long *pval, const char *name)
2126
{
2127
    const MonitorDef *md;
bellard authored
2128
2129
    void *ptr;
2130
2131
2132
    for(md = monitor_defs; md->name != NULL; md++) {
        if (compare_cmd(name, md->name)) {
            if (md->get_value) {
2133
                *pval = md->get_value(md, md->offset);
2134
            } else {
bellard authored
2135
2136
2137
2138
                CPUState *env = mon_get_cpu();
                if (!env)
                    return -2;
                ptr = (uint8_t *)env + md->offset;
bellard authored
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
                switch(md->type) {
                case MD_I32:
                    *pval = *(int32_t *)ptr;
                    break;
                case MD_TLONG:
                    *pval = *(target_long *)ptr;
                    break;
                default:
                    *pval = 0;
                    break;
                }
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
            }
            return 0;
        }
    }
    return -1;
}

static void next(void)
{
    if (pch != '\0') {
        pch++;
2161
        while (qemu_isspace(*pch))
2162
2163
2164
2165
            pch++;
    }
}
2166
static int64_t expr_sum(Monitor *mon);
2167
2168
static int64_t expr_unary(Monitor *mon)
2169
{
blueswir1 authored
2170
    int64_t n;
2171
    char *p;
bellard authored
2172
    int ret;
2173
2174
2175
2176

    switch(*pch) {
    case '+':
        next();
2177
        n = expr_unary(mon);
2178
2179
2180
        break;
    case '-':
        next();
2181
        n = -expr_unary(mon);
2182
2183
2184
        break;
    case '~':
        next();
2185
        n = ~expr_unary(mon);
2186
2187
2188
        break;
    case '(':
        next();
2189
        n = expr_sum(mon);
2190
        if (*pch != ')') {
2191
            expr_error(mon, "')' expected");
2192
2193
2194
        }
        next();
        break;
bellard authored
2195
2196
2197
    case '\'':
        pch++;
        if (*pch == '\0')
2198
            expr_error(mon, "character constant expected");
bellard authored
2199
2200
2201
        n = *pch;
        pch++;
        if (*pch != '\'')
2202
            expr_error(mon, "missing terminating \' character");
bellard authored
2203
2204
        next();
        break;
2205
2206
2207
    case '$':
        {
            char buf[128], *q;
2208
            target_long reg=0;
2209
2210
2211
2212
2213
2214
            pch++;
            q = buf;
            while ((*pch >= 'a' && *pch <= 'z') ||
                   (*pch >= 'A' && *pch <= 'Z') ||
                   (*pch >= '0' && *pch <= '9') ||
2215
                   *pch == '_' || *pch == '.') {
2216
2217
2218
2219
                if ((q - buf) < sizeof(buf) - 1)
                    *q++ = *pch;
                pch++;
            }
2220
            while (qemu_isspace(*pch))
2221
2222
                pch++;
            *q = 0;
2223
            ret = get_monitor_def(&reg, buf);
bellard authored
2224
            if (ret == -1)
2225
                expr_error(mon, "unknown register");
2226
            else if (ret == -2)
2227
                expr_error(mon, "no cpu defined");
2228
            n = reg;
2229
2230
2231
        }
        break;
    case '\0':
2232
        expr_error(mon, "unexpected end of expression");
2233
2234
2235
        n = 0;
        break;
    default:
2236
#if TARGET_PHYS_ADDR_BITS > 32
bellard authored
2237
2238
        n = strtoull(pch, &p, 0);
#else
2239
        n = strtoul(pch, &p, 0);
bellard authored
2240
#endif
2241
        if (pch == p) {
2242
            expr_error(mon, "invalid char in expression");
2243
2244
        }
        pch = p;
2245
        while (qemu_isspace(*pch))
2246
2247
2248
2249
2250
2251
2252
            pch++;
        break;
    }
    return n;
}
2253
static int64_t expr_prod(Monitor *mon)
2254
{
blueswir1 authored
2255
    int64_t val, val2;
bellard authored
2256
    int op;
2257
2258
    val = expr_unary(mon);
2259
2260
2261
2262
2263
    for(;;) {
        op = *pch;
        if (op != '*' && op != '/' && op != '%')
            break;
        next();
2264
        val2 = expr_unary(mon);
2265
2266
2267
2268
2269
2270
2271
        switch(op) {
        default:
        case '*':
            val *= val2;
            break;
        case '/':
        case '%':
2272
            if (val2 == 0)
2273
                expr_error(mon, "division by zero");
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
            if (op == '/')
                val /= val2;
            else
                val %= val2;
            break;
        }
    }
    return val;
}
2284
static int64_t expr_logic(Monitor *mon)
2285
{
blueswir1 authored
2286
    int64_t val, val2;
bellard authored
2287
    int op;
2288
2289
    val = expr_prod(mon);
2290
2291
2292
2293
2294
    for(;;) {
        op = *pch;
        if (op != '&' && op != '|' && op != '^')
            break;
        next();
2295
        val2 = expr_prod(mon);
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
        switch(op) {
        default:
        case '&':
            val &= val2;
            break;
        case '|':
            val |= val2;
            break;
        case '^':
            val ^= val2;
            break;
        }
    }
    return val;
}
2312
static int64_t expr_sum(Monitor *mon)
2313
{
blueswir1 authored
2314
    int64_t val, val2;
bellard authored
2315
    int op;
2316
2317
    val = expr_logic(mon);
2318
2319
2320
2321
2322
    for(;;) {
        op = *pch;
        if (op != '+' && op != '-')
            break;
        next();
2323
        val2 = expr_logic(mon);
2324
2325
2326
2327
2328
2329
2330
2331
        if (op == '+')
            val += val2;
        else
            val -= val2;
    }
    return val;
}
2332
static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2333
2334
2335
2336
2337
2338
{
    pch = *pp;
    if (setjmp(expr_env)) {
        *pp = pch;
        return -1;
    }
2339
    while (qemu_isspace(*pch))
2340
        pch++;
2341
    *pval = expr_sum(mon);
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
    *pp = pch;
    return 0;
}

static int get_str(char *buf, int buf_size, const char **pp)
{
    const char *p;
    char *q;
    int c;
bellard authored
2352
    q = buf;
2353
    p = *pp;
2354
    while (qemu_isspace(*p))
2355
2356
2357
        p++;
    if (*p == '\0') {
    fail:
bellard authored
2358
        *q = '\0';
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
        *pp = p;
        return -1;
    }
    if (*p == '\"') {
        p++;
        while (*p != '\0' && *p != '\"') {
            if (*p == '\\') {
                p++;
                c = *p++;
                switch(c) {
                case 'n':
                    c = '\n';
                    break;
                case 'r':
                    c = '\r';
                    break;
                case '\\':
                case '\'':
                case '\"':
                    break;
                default:
                    qemu_printf("unsupported escape code: '\\%c'\n", c);
                    goto fail;
                }
                if ((q - buf) < buf_size - 1) {
                    *q++ = c;
                }
            } else {
                if ((q - buf) < buf_size - 1) {
                    *q++ = *p;
                }
                p++;
            }
        }
        if (*p != '\"') {
bellard authored
2394
            qemu_printf("unterminated string\n");
2395
2396
2397
2398
            goto fail;
        }
        p++;
    } else {
2399
        while (*p != '\0' && !qemu_isspace(*p)) {
2400
2401
2402
2403
2404
2405
            if ((q - buf) < buf_size - 1) {
                *q++ = *p;
            }
            p++;
        }
    }
bellard authored
2406
    *q = '\0';
2407
2408
2409
2410
    *pp = p;
    return 0;
}
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
/*
 * Store the command-name in cmdname, and return a pointer to
 * the remaining of the command string.
 */
static const char *get_command_name(const char *cmdline,
                                    char *cmdname, size_t nlen)
{
    size_t len;
    const char *p, *pstart;

    p = cmdline;
    while (qemu_isspace(*p))
        p++;
    if (*p == '\0')
        return NULL;
    pstart = p;
    while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
        p++;
    len = p - pstart;
    if (len > nlen - 1)
        len = nlen - 1;
    memcpy(cmdname, pstart, len);
    cmdname[len] = '\0';
    return p;
}
2437
2438
2439
2440
2441
static int default_fmt_format = 'x';
static int default_fmt_size = 4;

#define MAX_ARGS 16
2442
static void monitor_handle_command(Monitor *mon, const char *cmdline)
2443
{
2444
2445
    const char *p, *typestr;
    int c, nb_args, i, has_arg;
2446
    const mon_cmd_t *cmd;
2447
2448
2449
2450
    char cmdname[256];
    char buf[1024];
    void *str_allocated[MAX_ARGS];
    void *args[MAX_ARGS];
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
    void (*handler_0)(Monitor *mon);
    void (*handler_1)(Monitor *mon, void *arg0);
    void (*handler_2)(Monitor *mon, void *arg0, void *arg1);
    void (*handler_3)(Monitor *mon, void *arg0, void *arg1, void *arg2);
    void (*handler_4)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                      void *arg3);
    void (*handler_5)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                      void *arg3, void *arg4);
    void (*handler_6)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                      void *arg3, void *arg4, void *arg5);
    void (*handler_7)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                      void *arg3, void *arg4, void *arg5, void *arg6);
2463
2464
2465
2466
2467
2468
2469
2470
2471
    void (*handler_8)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                      void *arg3, void *arg4, void *arg5, void *arg6,
                      void *arg7);
    void (*handler_9)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                      void *arg3, void *arg4, void *arg5, void *arg6,
                      void *arg7, void *arg8);
    void (*handler_10)(Monitor *mon, void *arg0, void *arg1, void *arg2,
                       void *arg3, void *arg4, void *arg5, void *arg6,
                       void *arg7, void *arg8, void *arg9);
bellard authored
2472
2473

#ifdef DEBUG
2474
    monitor_printf(mon, "command='%s'\n", cmdline);
bellard authored
2475
#endif
2476
2477
    /* extract the command name */
2478
2479
    p = get_command_name(cmdline, cmdname, sizeof(cmdname));
    if (!p)
2480
        return;
2481
2482
    /* find the command */
2483
    for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
2484
        if (compare_cmd(cmdname, cmd->name))
2485
2486
2487
2488
2489
2490
            break;
    }

    if (cmd->name == NULL) {
        monitor_printf(mon, "unknown command: '%s'\n", cmdname);
        return;
2491
2492
2493
2494
    }

    for(i = 0; i < MAX_ARGS; i++)
        str_allocated[i] = NULL;
2495
2496
2497
2498
    /* parse the parameters */
    typestr = cmd->args_type;
    nb_args = 0;
bellard authored
2499
    for(;;) {
2500
2501
        c = *typestr;
        if (c == '\0')
bellard authored
2502
            break;
2503
2504
2505
        typestr++;
        switch(c) {
        case 'F':
bellard authored
2506
        case 'B':
2507
2508
2509
2510
        case 's':
            {
                int ret;
                char *str;
2511
2512
                while (qemu_isspace(*p))
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
                    p++;
                if (*typestr == '?') {
                    typestr++;
                    if (*p == '\0') {
                        /* no optional string: NULL argument */
                        str = NULL;
                        goto add_str;
                    }
                }
                ret = get_str(buf, sizeof(buf), &p);
                if (ret < 0) {
bellard authored
2524
2525
                    switch(c) {
                    case 'F':
2526
2527
                        monitor_printf(mon, "%s: filename expected\n",
                                       cmdname);
bellard authored
2528
2529
                        break;
                    case 'B':
2530
2531
                        monitor_printf(mon, "%s: block device name expected\n",
                                       cmdname);
bellard authored
2532
2533
                        break;
                    default:
2534
                        monitor_printf(mon, "%s: string expected\n", cmdname);
bellard authored
2535
2536
                        break;
                    }
2537
2538
2539
                    goto fail;
                }
                str = qemu_malloc(strlen(buf) + 1);
2540
                pstrcpy(str, sizeof(buf), buf);
2541
2542
2543
2544
                str_allocated[nb_args] = str;
            add_str:
                if (nb_args >= MAX_ARGS) {
                error_args:
2545
                    monitor_printf(mon, "%s: too many arguments\n", cmdname);
2546
2547
2548
2549
                    goto fail;
                }
                args[nb_args++] = str;
            }
bellard authored
2550
            break;
2551
2552
2553
        case '/':
            {
                int count, format, size;
2554
2555
                while (qemu_isspace(*p))
2556
2557
2558
2559
2560
                    p++;
                if (*p == '/') {
                    /* format found */
                    p++;
                    count = 1;
2561
                    if (qemu_isdigit(*p)) {
2562
                        count = 0;
2563
                        while (qemu_isdigit(*p)) {
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
                            count = count * 10 + (*p - '0');
                            p++;
                        }
                    }
                    size = -1;
                    format = -1;
                    for(;;) {
                        switch(*p) {
                        case 'o':
                        case 'd':
                        case 'u':
                        case 'x':
                        case 'i':
                        case 'c':
                            format = *p++;
                            break;
                        case 'b':
                            size = 1;
                            p++;
                            break;
                        case 'h':
                            size = 2;
                            p++;
                            break;
                        case 'w':
                            size = 4;
                            p++;
                            break;
                        case 'g':
                        case 'L':
                            size = 8;
                            p++;
                            break;
                        default:
                            goto next;
                        }
                    }
                next:
2602
                    if (*p != '\0' && !qemu_isspace(*p)) {
2603
2604
                        monitor_printf(mon, "invalid char in format: '%c'\n",
                                       *p);
2605
2606
2607
2608
                        goto fail;
                    }
                    if (format < 0)
                        format = default_fmt_format;
2609
2610
2611
2612
                    if (format != 'i') {
                        /* for 'i', not specifying a size gives -1 as size */
                        if (size < 0)
                            size = default_fmt_size;
2613
                        default_fmt_size = size;
2614
                    }
2615
2616
2617
2618
                    default_fmt_format = format;
                } else {
                    count = 1;
                    format = default_fmt_format;
2619
2620
2621
2622
2623
                    if (format != 'i') {
                        size = default_fmt_size;
                    } else {
                        size = -1;
                    }
2624
2625
2626
                }
                if (nb_args + 3 > MAX_ARGS)
                    goto error_args;
2627
2628
2629
                args[nb_args++] = (void*)(long)count;
                args[nb_args++] = (void*)(long)format;
                args[nb_args++] = (void*)(long)size;
2630
            }
bellard authored
2631
            break;
2632
        case 'i':
bellard authored
2633
        case 'l':
2634
            {
blueswir1 authored
2635
                int64_t val;
2636
2637
                while (qemu_isspace(*p))
2638
                    p++;
bellard authored
2639
2640
2641
2642
2643
2644
2645
2646
2647
                if (*typestr == '?' || *typestr == '.') {
                    if (*typestr == '?') {
                        if (*p == '\0')
                            has_arg = 0;
                        else
                            has_arg = 1;
                    } else {
                        if (*p == '.') {
                            p++;
2648
                            while (qemu_isspace(*p))
bellard authored
2649
2650
2651
2652
2653
2654
                                p++;
                            has_arg = 1;
                        } else {
                            has_arg = 0;
                        }
                    }
bellard authored
2655
                    typestr++;
2656
2657
                    if (nb_args >= MAX_ARGS)
                        goto error_args;
2658
                    args[nb_args++] = (void *)(long)has_arg;
2659
2660
2661
2662
2663
2664
2665
                    if (!has_arg) {
                        if (nb_args >= MAX_ARGS)
                            goto error_args;
                        val = -1;
                        goto add_num;
                    }
                }
2666
                if (get_expr(mon, &val, &p))
2667
2668
                    goto fail;
            add_num:
bellard authored
2669
2670
2671
                if (c == 'i') {
                    if (nb_args >= MAX_ARGS)
                        goto error_args;
2672
                    args[nb_args++] = (void *)(long)val;
bellard authored
2673
2674
2675
                } else {
                    if ((nb_args + 1) >= MAX_ARGS)
                        goto error_args;
2676
#if TARGET_PHYS_ADDR_BITS > 32
2677
                    args[nb_args++] = (void *)(long)((val >> 32) & 0xffffffff);
bellard authored
2678
2679
2680
#else
                    args[nb_args++] = (void *)0;
#endif
2681
                    args[nb_args++] = (void *)(long)(val & 0xffffffff);
bellard authored
2682
                }
2683
2684
2685
2686
2687
2688
            }
            break;
        case '-':
            {
                int has_option;
                /* option */
2689
2690
2691
2692
                c = *typestr++;
                if (c == '\0')
                    goto bad_type;
2693
                while (qemu_isspace(*p))
2694
2695
2696
2697
2698
                    p++;
                has_option = 0;
                if (*p == '-') {
                    p++;
                    if (*p != c) {
2699
2700
                        monitor_printf(mon, "%s: unsupported option -%c\n",
                                       cmdname, *p);
2701
2702
2703
2704
2705
2706
2707
                        goto fail;
                    }
                    p++;
                    has_option = 1;
                }
                if (nb_args >= MAX_ARGS)
                    goto error_args;
2708
                args[nb_args++] = (void *)(long)has_option;
2709
2710
2711
2712
            }
            break;
        default:
        bad_type:
2713
            monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
2714
2715
            goto fail;
        }
bellard authored
2716
    }
2717
    /* check that all arguments were parsed */
2718
    while (qemu_isspace(*p))
2719
2720
        p++;
    if (*p != '\0') {
2721
2722
        monitor_printf(mon, "%s: extraneous characters at the end of line\n",
                       cmdname);
2723
        goto fail;
bellard authored
2724
    }
2725
2726
2727

    switch(nb_args) {
    case 0:
2728
        handler_0 = cmd->handler;
2729
        handler_0(mon);
2730
2731
        break;
    case 1:
2732
        handler_1 = cmd->handler;
2733
        handler_1(mon, args[0]);
2734
2735
        break;
    case 2:
2736
        handler_2 = cmd->handler;
2737
        handler_2(mon, args[0], args[1]);
2738
2739
        break;
    case 3:
2740
        handler_3 = cmd->handler;
2741
        handler_3(mon, args[0], args[1], args[2]);
2742
2743
        break;
    case 4:
2744
        handler_4 = cmd->handler;
2745
        handler_4(mon, args[0], args[1], args[2], args[3]);
2746
2747
        break;
    case 5:
2748
        handler_5 = cmd->handler;
2749
        handler_5(mon, args[0], args[1], args[2], args[3], args[4]);
2750
        break;
bellard authored
2751
    case 6:
2752
        handler_6 = cmd->handler;
2753
        handler_6(mon, args[0], args[1], args[2], args[3], args[4], args[5]);
bellard authored
2754
        break;
2755
    case 7:
2756
        handler_7 = cmd->handler;
2757
2758
        handler_7(mon, args[0], args[1], args[2], args[3], args[4], args[5],
                  args[6]);
2759
        break;
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
    case 8:
        handler_8 = cmd->handler;
        handler_8(mon, args[0], args[1], args[2], args[3], args[4], args[5],
                  args[6], args[7]);
        break;
    case 9:
        handler_9 = cmd->handler;
        handler_9(mon, args[0], args[1], args[2], args[3], args[4], args[5],
                  args[6], args[7], args[8]);
        break;
    case 10:
        handler_10 = cmd->handler;
        handler_10(mon, args[0], args[1], args[2], args[3], args[4], args[5],
                   args[6], args[7], args[8], args[9]);
        break;
2775
    default:
2776
        monitor_printf(mon, "unsupported number of arguments: %d\n", nb_args);
2777
        goto fail;
bellard authored
2778
    }
2779
2780
2781
 fail:
    for(i = 0; i < MAX_ARGS; i++)
        qemu_free(str_allocated[i]);
bellard authored
2782
2783
}
bellard authored
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
static void cmd_completion(const char *name, const char *list)
{
    const char *p, *pstart;
    char cmd[128];
    int len;

    p = list;
    for(;;) {
        pstart = p;
        p = strchr(p, '|');
        if (!p)
            p = pstart + strlen(pstart);
        len = p - pstart;
        if (len > sizeof(cmd) - 2)
            len = sizeof(cmd) - 2;
        memcpy(cmd, pstart, len);
        cmd[len] = '\0';
        if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
2802
            readline_add_completion(cur_mon->rs, cmd);
bellard authored
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
        }
        if (*p == '\0')
            break;
        p++;
    }
}

static void file_completion(const char *input)
{
    DIR *ffs;
    struct dirent *d;
    char path[1024];
    char file[1024], file_prefix[1024];
    int input_path_len;
    const char *p;
2819
    p = strrchr(input, '/');
bellard authored
2820
2821
2822
    if (!p) {
        input_path_len = 0;
        pstrcpy(file_prefix, sizeof(file_prefix), input);
2823
        pstrcpy(path, sizeof(path), ".");
bellard authored
2824
2825
2826
2827
2828
2829
2830
2831
2832
    } else {
        input_path_len = p - input + 1;
        memcpy(path, input, input_path_len);
        if (input_path_len > sizeof(path) - 1)
            input_path_len = sizeof(path) - 1;
        path[input_path_len] = '\0';
        pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
    }
#ifdef DEBUG_COMPLETION
2833
2834
    monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
                   input, path, file_prefix);
bellard authored
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
#endif
    ffs = opendir(path);
    if (!ffs)
        return;
    for(;;) {
        struct stat sb;
        d = readdir(ffs);
        if (!d)
            break;
        if (strstart(d->d_name, file_prefix, NULL)) {
            memcpy(file, input, input_path_len);
2846
2847
2848
            if (input_path_len < sizeof(file))
                pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
                        d->d_name);
bellard authored
2849
2850
2851
2852
2853
            /* stat the file to find out if it's a directory.
             * In that case add a slash to speed up typing long paths
             */
            stat(file, &sb);
            if(S_ISDIR(sb.st_mode))
2854
                pstrcat(file, sizeof(file), "/");
2855
            readline_add_completion(cur_mon->rs, file);
bellard authored
2856
2857
2858
2859
2860
        }
    }
    closedir(ffs);
}
2861
static void block_completion_it(void *opaque, BlockDriverState *bs)
bellard authored
2862
{
2863
    const char *name = bdrv_get_device_name(bs);
bellard authored
2864
2865
2866
2867
    const char *input = opaque;

    if (input[0] == '\0' ||
        !strncmp(name, (char *)input, strlen(input))) {
2868
        readline_add_completion(cur_mon->rs, name);
bellard authored
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
    }
}

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

    p = cmdline;
    nb_args = 0;
    for(;;) {
2883
        while (qemu_isspace(*p))
bellard authored
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
            p++;
        if (*p == '\0')
            break;
        if (nb_args >= MAX_ARGS)
            break;
        ret = get_str(buf, sizeof(buf), &p);
        args[nb_args] = qemu_strdup(buf);
        nb_args++;
        if (ret < 0)
            break;
    }
    *pnb_args = nb_args;
}
2898
static void monitor_find_completion(const char *cmdline)
bellard authored
2899
2900
2901
2902
2903
{
    const char *cmdname;
    char *args[MAX_ARGS];
    int nb_args, i, len;
    const char *ptype, *str;
2904
    const mon_cmd_t *cmd;
2905
    const KeyDef *key;
bellard authored
2906
2907
2908
2909

    parse_cmdline(cmdline, &nb_args, args);
#ifdef DEBUG_COMPLETION
    for(i = 0; i < nb_args; i++) {
2910
        monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
bellard authored
2911
2912
2913
2914
2915
2916
    }
#endif

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

    return (mon->suspend_cnt == 0) ? 128 : 0;
bellard authored
2995
2996
}
2997
static void monitor_read(void *opaque, const uint8_t *buf, int size)
bellard authored
2998
{
2999
    Monitor *old_mon = cur_mon;
3000
    int i;
3001
3002
3003
    cur_mon = opaque;
3004
3005
3006
3007
3008
3009
3010
3011
3012
    if (cur_mon->rs) {
        for (i = 0; i < size; i++)
            readline_handle_byte(cur_mon->rs, buf[i]);
    } else {
        if (size == 0 || buf[size - 1] != 0)
            monitor_printf(cur_mon, "corrupted command\n");
        else
            monitor_handle_command(cur_mon, (char *)buf);
    }
bellard authored
3013
3014
3015
    cur_mon = old_mon;
}
3016
3017
static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
3018
{
3019
    monitor_suspend(mon);
3020
    monitor_handle_command(mon, cmdline);
3021
    monitor_resume(mon);
3022
3023
}
3024
int monitor_suspend(Monitor *mon)
3025
{
3026
3027
    if (!mon->rs)
        return -ENOTTY;
3028
    mon->suspend_cnt++;
3029
    return 0;
3030
3031
}
3032
void monitor_resume(Monitor *mon)
3033
{
3034
3035
    if (!mon->rs)
        return;
3036
3037
    if (--mon->suspend_cnt == 0)
        readline_show_prompt(mon->rs);
3038
3039
}
3040
static void monitor_event(void *opaque, int event)
3041
{
3042
3043
    Monitor *mon = opaque;
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
    switch (event) {
    case CHR_EVENT_MUX_IN:
        readline_restart(mon->rs);
        monitor_resume(mon);
        monitor_flush(mon);
        break;

    case CHR_EVENT_MUX_OUT:
        if (mon->suspend_cnt == 0)
            monitor_printf(mon, "\n");
        monitor_flush(mon);
        monitor_suspend(mon);
        break;
3057
3058
3059
3060
3061
3062
3063
3064
    case CHR_EVENT_RESET:
        monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
                       "information\n", QEMU_VERSION);
        if (mon->chr->focus == 0)
            readline_show_prompt(mon->rs);
        break;
    }
3065
3066
}
3067
3068
3069
3070
3071
3072
3073
3074
3075

/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 *  tab-width: 8
 * End:
 */
3076
void monitor_init(CharDriverState *chr, int flags)
3077
{
3078
    static int is_first_init = 1;
3079
    Monitor *mon;
3080
3081

    if (is_first_init) {
3082
        key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
3083
3084
        is_first_init = 0;
    }
3085
3086

    mon = qemu_mallocz(sizeof(*mon));
3087
3088
    mon->chr = chr;
3089
    mon->flags = flags;
3090
3091
    if (mon->chr->focus != 0)
        mon->suspend_cnt = 1; /* mux'ed monitors start suspended */
3092
3093
3094
3095
    if (flags & MONITOR_USE_READLINE) {
        mon->rs = readline_init(mon, monitor_find_completion);
        monitor_read_command(mon, 0);
    }
3096
3097
3098
    qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event,
                          mon);
3099
3100

    LIST_INSERT_HEAD(&mon_list, mon, entry);
3101
    if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
3102
        cur_mon = mon;
3103
3104
}
3105
static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
bellard authored
3106
{
3107
3108
    BlockDriverState *bs = opaque;
    int ret = 0;
bellard authored
3109
3110
    if (bdrv_set_key(bs, password) != 0) {
3111
        monitor_printf(mon, "invalid password\n");
3112
        ret = -EPERM;
bellard authored
3113
    }
3114
3115
    if (mon->password_completion_cb)
        mon->password_completion_cb(mon->password_opaque, ret);
3116
3117
    monitor_read_command(mon, 1);
bellard authored
3118
}
3119
3120
void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
3121
3122
                                 BlockDriverCompletionFunc *completion_cb,
                                 void *opaque)
3123
{
3124
3125
    int err;
3126
3127
3128
3129
3130
    if (!bdrv_key_required(bs)) {
        if (completion_cb)
            completion_cb(opaque, 0);
        return;
    }
3131
3132
3133
    monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
                   bdrv_get_encrypted_filename(bs));
3134
3135
3136
    mon->password_completion_cb = completion_cb;
    mon->password_opaque = opaque;
3137
3138
3139
3140
3141
    err = monitor_read_password(mon, bdrv_password_cb, bs);

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