Blame view

monitor.c 83.2 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
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
{
    uint32_t val;
    int suffix;

    if (has_index) {
        cpu_outb(NULL, addr & 0xffff, index & 0xff);
        addr++;
    }
    addr &= 0xffff;

    switch(size) {
    default:
    case 1:
        val = cpu_inb(NULL, addr);
        suffix = 'b';
        break;
    case 2:
        val = cpu_inw(NULL, addr);
        suffix = 'w';
        break;
    case 4:
        val = cpu_inl(NULL, addr);
        suffix = 'l';
        break;
    }
1184
1185
    monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
                   suffix, addr, size * 2, val);
bellard authored
1186
}
bellard authored
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
/* boot_set handler */
static QEMUBootSetHandler *qemu_boot_set_handler = NULL;
static void *boot_opaque;

void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
{
    qemu_boot_set_handler = func;
    boot_opaque = opaque;
}
1198
static void do_boot_set(Monitor *mon, const char *bootdevice)
1199
1200
1201
1202
{
    int res;

    if (qemu_boot_set_handler)  {
1203
        res = qemu_boot_set_handler(boot_opaque, bootdevice);
1204
        if (res == 0)
1205
1206
            monitor_printf(mon, "boot device list now set to %s\n",
                           bootdevice);
1207
        else
1208
1209
            monitor_printf(mon, "setting boot device list failed with "
                           "error %i\n", res);
1210
    } else {
1211
1212
        monitor_printf(mon, "no function defined to set boot device list for "
                       "this architecture\n");
1213
1214
1215
    }
}
1216
static void do_system_reset(Monitor *mon)
bellard authored
1217
1218
1219
1220
{
    qemu_system_reset_request();
}
1221
static void do_system_powerdown(Monitor *mon)
bellard authored
1222
1223
1224
1225
{
    qemu_system_powerdown_request();
}
bellard authored
1226
#if defined(TARGET_I386)
1227
static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
bellard authored
1228
{
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
    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
1240
1241
}
1242
static void tlb_info(Monitor *mon)
bellard authored
1243
{
bellard authored
1244
    CPUState *env;
bellard authored
1245
1246
1247
    int l1, l2;
    uint32_t pgd, pde, pte;
bellard authored
1248
1249
1250
1251
    env = mon_get_cpu();
    if (!env)
        return;
bellard authored
1252
    if (!(env->cr[0] & CR0_PG_MASK)) {
1253
        monitor_printf(mon, "PG disabled\n");
bellard authored
1254
1255
1256
1257
1258
1259
1260
1261
        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)) {
1262
                print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
bellard authored
1263
1264
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1265
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
bellard authored
1266
1267
1268
                                             (uint8_t *)&pte, 4);
                    pte = le32_to_cpu(pte);
                    if (pte & PG_PRESENT_MASK) {
1269
                        print_pte(mon, (l1 << 22) + (l2 << 12),
1270
                                  pte & ~PG_PSE_MASK,
bellard authored
1271
1272
1273
1274
1275
1276
1277
1278
                                  ~0xfff);
                    }
                }
            }
        }
    }
}
1279
static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
bellard authored
1280
1281
                      uint32_t end, int prot)
{
1282
1283
1284
    int prot1;
    prot1 = *plast_prot;
    if (prot != prot1) {
bellard authored
1285
        if (*pstart != -1) {
1286
1287
1288
1289
1290
            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
1291
1292
1293
1294
1295
1296
1297
1298
1299
        }
        if (prot != 0)
            *pstart = end;
        else
            *pstart = -1;
        *plast_prot = prot;
    }
}
1300
static void mem_info(Monitor *mon)
bellard authored
1301
{
bellard authored
1302
    CPUState *env;
bellard authored
1303
1304
1305
    int l1, l2, prot, last_prot;
    uint32_t pgd, pde, pte, start, end;
bellard authored
1306
1307
1308
1309
    env = mon_get_cpu();
    if (!env)
        return;
bellard authored
1310
    if (!(env->cr[0] & CR0_PG_MASK)) {
1311
        monitor_printf(mon, "PG disabled\n");
bellard authored
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
        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);
1324
                mem_print(mon, &start, &last_prot, end, prot);
bellard authored
1325
1326
            } else {
                for(l2 = 0; l2 < 1024; l2++) {
1327
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
bellard authored
1328
1329
1330
1331
1332
1333
1334
1335
                                             (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;
                    }
1336
                    mem_print(mon, &start, &last_prot, end, prot);
bellard authored
1337
1338
1339
1340
                }
            }
        } else {
            prot = 0;
1341
            mem_print(mon, &start, &last_prot, end, prot);
bellard authored
1342
1343
1344
1345
1346
        }
    }
}
#endif
1347
1348
#if defined(TARGET_SH4)
1349
static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
1350
{
1351
1352
1353
1354
1355
1356
1357
1358
    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);
1359
1360
}
1361
static void tlb_info(Monitor *mon)
1362
1363
1364
1365
{
    CPUState *env = mon_get_cpu();
    int i;
1366
    monitor_printf (mon, "ITLB:\n");
1367
    for (i = 0 ; i < ITLB_SIZE ; i++)
1368
1369
        print_tlb (mon, i, &env->itlb[i]);
    monitor_printf (mon, "UTLB:\n");
1370
    for (i = 0 ; i < UTLB_SIZE ; i++)
1371
        print_tlb (mon, i, &env->utlb[i]);
1372
1373
1374
1375
}

#endif
1376
static void do_info_kqemu(Monitor *mon)
bellard authored
1377
{
1378
#ifdef CONFIG_KQEMU
bellard authored
1379
    CPUState *env;
bellard authored
1380
1381
    int val;
    val = 0;
bellard authored
1382
1383
    env = mon_get_cpu();
    if (!env) {
1384
        monitor_printf(mon, "No cpu initialized yet");
bellard authored
1385
1386
1387
        return;
    }
    val = env->kqemu_enabled;
1388
    monitor_printf(mon, "kqemu support: ");
bellard authored
1389
1390
1391
    switch(val) {
    default:
    case 0:
1392
        monitor_printf(mon, "disabled\n");
bellard authored
1393
1394
        break;
    case 1:
1395
        monitor_printf(mon, "enabled for user code\n");
bellard authored
1396
1397
        break;
    case 2:
1398
        monitor_printf(mon, "enabled for user and kernel code\n");
bellard authored
1399
1400
        break;
    }
bellard authored
1401
#else
1402
    monitor_printf(mon, "kqemu support: not compiled\n");
bellard authored
1403
#endif
1404
}
bellard authored
1405
1406
static void do_info_kvm(Monitor *mon)
aliguori authored
1407
1408
{
#ifdef CONFIG_KVM
1409
    monitor_printf(mon, "kvm support: ");
aliguori authored
1410
    if (kvm_enabled())
1411
        monitor_printf(mon, "enabled\n");
aliguori authored
1412
    else
1413
        monitor_printf(mon, "disabled\n");
aliguori authored
1414
#else
1415
    monitor_printf(mon, "kvm support: not compiled\n");
aliguori authored
1416
1417
1418
#endif
}
1419
1420
static void do_info_numa(Monitor *mon)
{
1421
    int i;
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
    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
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
#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;
1448
static void do_info_profile(Monitor *mon)
bellard authored
1449
1450
1451
1452
1453
{
    int64_t total;
    total = qemu_time;
    if (total == 0)
        total = 1;
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
    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
1467
1468
1469
1470
1471
1472
1473
    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;
1474
#ifdef CONFIG_KQEMU
bellard authored
1475
1476
1477
1478
    kqemu_record_dump();
#endif
}
#else
1479
static void do_info_profile(Monitor *mon)
bellard authored
1480
{
1481
    monitor_printf(mon, "Internal profiler not compiled\n");
bellard authored
1482
1483
1484
}
#endif
1485
1486
1487
/* Capture support */
static LIST_HEAD (capture_list_head, CaptureState) capture_head;
1488
static void do_info_capture(Monitor *mon)
1489
1490
1491
1492
1493
{
    int i;
    CaptureState *s;

    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1494
        monitor_printf(mon, "[%d]: ", i);
1495
1496
1497
1498
        s->ops.info (s->opaque);
    }
}
1499
#ifdef HAS_AUDIO
1500
static void do_stop_capture(Monitor *mon, int n)
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
{
    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;
        }
    }
}
1515
1516
1517
1518
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)
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
{
    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)) {
1529
        monitor_printf(mon, "Faied to add wave capture\n");
1530
1531
1532
1533
1534
1535
        qemu_free (s);
    }
    LIST_INSERT_HEAD (&capture_head, s, entries);
}
#endif
1536
#if defined(TARGET_I386)
1537
static void do_inject_nmi(Monitor *mon, int cpu_index)
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
{
    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
1549
static void do_info_status(Monitor *mon)
aurel32 authored
1550
{
1551
1552
1553
1554
1555
1556
1557
    if (vm_running) {
        if (singlestep) {
            monitor_printf(mon, "VM status: running (single step mode)\n");
        } else {
            monitor_printf(mon, "VM status: running\n");
        }
    } else
1558
       monitor_printf(mon, "VM status: paused\n");
aurel32 authored
1559
1560
1561
}
1562
static void do_balloon(Monitor *mon, int value)
1563
1564
1565
1566
1567
{
    ram_addr_t target = value;
    qemu_balloon(target << 20);
}
1568
static void do_info_balloon(Monitor *mon)
1569
1570
1571
1572
{
    ram_addr_t actual;

    actual = qemu_balloon_status();
aliguori authored
1573
    if (kvm_enabled() && !kvm_has_sync_mmu())
1574
1575
        monitor_printf(mon, "Using KVM without synchronous MMU, "
                       "ballooning disabled\n");
aliguori authored
1576
    else if (actual == 0)
1577
        monitor_printf(mon, "Ballooning not activated in VM\n");
1578
    else
1579
        monitor_printf(mon, "balloon: actual=%d\n", (int)(actual >> 20));
1580
1581
}
1582
static qemu_acl *find_acl(Monitor *mon, const char *name)
1583
{
1584
    qemu_acl *acl = qemu_acl_find(name);
1585
1586

    if (!acl) {
1587
        monitor_printf(mon, "acl: unknown list '%s'\n", name);
1588
    }
1589
1590
1591
1592
1593
1594
1595
1596
    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;
1597
1598
    if (acl) {
1599
        monitor_printf(mon, "policy: %s\n",
1600
                       acl->defaultDeny ? "deny" : "allow");
1601
1602
1603
        TAILQ_FOREACH(entry, &acl->entries, next) {
            i++;
            monitor_printf(mon, "%d: %s %s\n", i,
1604
                           entry->deny ? "deny" : "allow", entry->match);
1605
        }
1606
1607
1608
1609
1610
1611
1612
1613
    }
}

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

    if (acl) {
1614
1615
        qemu_acl_reset(acl);
        monitor_printf(mon, "acl: removed all rules\n");
1616
1617
1618
1619
1620
1621
1622
    }
}

static void do_acl_policy(Monitor *mon, const char *aclname,
                          const char *policy)
{
    qemu_acl *acl = find_acl(mon, aclname);
1623
1624
1625
    if (acl) {
        if (strcmp(policy, "allow") == 0) {
1626
1627
            acl->defaultDeny = 0;
            monitor_printf(mon, "acl: policy set to 'allow'\n");
1628
        } else if (strcmp(policy, "deny") == 0) {
1629
1630
1631
            acl->defaultDeny = 1;
            monitor_printf(mon, "acl: policy set to 'deny'\n");
        } else {
1632
1633
            monitor_printf(mon, "acl: unknown policy '%s', "
                           "expected 'deny' or 'allow'\n", policy);
1634
        }
1635
1636
    }
}
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
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);
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
            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);
1663
1664
    }
}
1665
1666
1667
1668
1669
static void do_acl_remove(Monitor *mon, const char *aclname, const char *match)
{
    qemu_acl *acl = find_acl(mon, aclname);
    int ret;
1670
1671
    if (acl) {
1672
1673
1674
1675
1676
        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);
1677
1678
1679
    }
}
1680
static const mon_cmd_t mon_cmds[] = {
1681
#include "qemu-monitor.h"
1682
    { NULL, NULL, },
bellard authored
1683
1684
};
1685
/* Please update qemu-monitor.hx when adding or changing commands */
1686
static const mon_cmd_t info_cmds[] = {
bellard authored
1687
    { "version", "", do_info_version,
blueswir1 authored
1688
      "", "show the version of QEMU" },
1689
    { "network", "", do_info_network,
bellard authored
1690
      "", "show the network state" },
1691
1692
    { "chardev", "", qemu_chr_info,
      "", "show the character devices" },
1693
    { "block", "", bdrv_info,
bellard authored
1694
      "", "show the block devices" },
1695
    { "blockstats", "", bdrv_info_stats,
1696
      "", "show block device statistics" },
1697
1698
    { "registers", "", do_info_registers,
      "", "show the cpu registers" },
bellard authored
1699
1700
    { "cpus", "", do_info_cpus,
      "", "show infos for each CPU" },
1701
1702
    { "history", "", do_info_history,
      "", "show the command line history", },
1703
1704
    { "irq", "", irq_info,
      "", "show the interrupts statistics (if available)", },
1705
1706
    { "pic", "", pic_info,
      "", "show i8259 (PIC) state", },
bellard authored
1707
1708
    { "pci", "", pci_info,
      "", "show PCI info", },
1709
#if defined(TARGET_I386) || defined(TARGET_SH4)
bellard authored
1710
1711
    { "tlb", "", tlb_info,
      "", "show virtual to physical memory mappings", },
1712
1713
#endif
#if defined(TARGET_I386)
bellard authored
1714
1715
    { "mem", "", mem_info,
      "", "show the active virtual memory mappings", },
1716
1717
    { "hpet", "", do_info_hpet,
      "", "show state of HPET", },
bellard authored
1718
#endif
bellard authored
1719
1720
    { "jit", "", do_info_jit,
      "", "show dynamic compiler info", },
bellard authored
1721
    { "kqemu", "", do_info_kqemu,
blueswir1 authored
1722
      "", "show KQEMU information", },
aliguori authored
1723
    { "kvm", "", do_info_kvm,
blueswir1 authored
1724
      "", "show KVM information", },
1725
1726
    { "numa", "", do_info_numa,
      "", "show NUMA information", },
bellard authored
1727
1728
1729
1730
    { "usb", "", usb_info,
      "", "show guest USB devices", },
    { "usbhost", "", usb_host_info,
      "", "show host USB devices", },
bellard authored
1731
1732
    { "profile", "", do_info_profile,
      "", "show profiling information", },
1733
    { "capture", "", do_info_capture,
bellard authored
1734
      "", "show capture information" },
bellard authored
1735
    { "snapshots", "", do_info_snapshots,
bellard authored
1736
      "", "show the currently saved VM snapshots" },
aurel32 authored
1737
1738
    { "status", "", do_info_status,
      "", "show the current VM status (running|paused)" },
1739
1740
    { "pcmcia", "", pcmcia_info,
      "", "show guest PCMCIA status" },
1741
1742
    { "mice", "", do_info_mice,
      "", "show which guest mouse is receiving events" },
1743
1744
    { "vnc", "", do_info_vnc,
      "", "show the vnc server status"},
1745
1746
    { "name", "", do_info_name,
      "", "show the current VM name" },
1747
1748
    { "uuid", "", do_info_uuid,
      "", "show the current VM UUID" },
1749
1750
1751
1752
#if defined(TARGET_PPC)
    { "cpustats", "", do_info_cpu_stats,
      "", "show CPU statistics", },
#endif
1753
#if defined(CONFIG_SLIRP)
1754
1755
    { "usernet", "", do_info_usernet,
      "", "show user network stack connection states", },
1756
#endif
1757
    { "migrate", "", do_info_migrate, "", "show migration status" },
1758
1759
    { "balloon", "", do_info_balloon,
      "", "show balloon information" },
1760
1761
    { "qtree", "", do_info_qtree,
      "", "show device tree" },
bellard authored
1762
1763
1764
    { NULL, NULL, },
};
1765
1766
1767
1768
1769
/*******************************************************************/

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

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

#define SEG(name, seg) \
bellard authored
1872
    { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
1873
    { name ".base", offsetof(CPUState, segs[seg].base) },\
bellard authored
1874
    { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
1875
1876
1877
1878
1879
1880
1881
1882
    { "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
1883
    { "edi", offsetof(CPUState, regs[7]) },
bellard authored
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
#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
1894
    { "eflags", offsetof(CPUState, eflags) },
1895
1896
1897
1898
    { "eip", offsetof(CPUState, eip) },
    SEG("cs", R_CS)
    SEG("ds", R_DS)
    SEG("es", R_ES)
bellard authored
1899
    SEG("ss", R_SS)
1900
1901
1902
    SEG("fs", R_FS)
    SEG("gs", R_GS)
    { "pc", 0, monitor_get_pc, },
1903
#elif defined(TARGET_PPC)
1904
    /* General purpose registers */
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
    { "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]) },
1937
1938
1939
1940
1941
1942
1943
1944
1945
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
    /* 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 */
1972
    { "nip|pc", offsetof(CPUState, nip) },
1973
1974
    { "lr", offsetof(CPUState, lr) },
    { "ctr", offsetof(CPUState, ctr) },
1975
    { "decr", 0, &monitor_get_decr, },
1976
    { "ccr", 0, &monitor_get_ccr, },
1977
    /* Machine state register */
1978
1979
    { "msr", 0, &monitor_get_msr, },
    { "xer", 0, &monitor_get_xer, },
1980
1981
    { "tbu", 0, &monitor_get_tbu, },
    { "tbl", 0, &monitor_get_tbl, },
1982
1983
1984
1985
1986
#if defined(TARGET_PPC64)
    /* Address space register */
    { "asr", offsetof(CPUState, asr) },
#endif
    /* Segment registers */
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
    { "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 ... */
2005
2006
2007
2008
2009
2010
2011
2012
2013
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
#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
2041
#ifndef TARGET_SPARC64
2042
2043
    { "psr", 0, &monitor_get_psr, },
    { "wim", offsetof(CPUState, wim) },
bellard authored
2044
#endif
2045
2046
2047
2048
2049
2050
2051
2052
2053
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
    { "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
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
#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
2105
2106
2107
2108
#endif
    { NULL },
};
2109
static void expr_error(Monitor *mon, const char *msg)
bellard authored
2110
{
2111
    monitor_printf(mon, "%s\n", msg);
2112
2113
2114
    longjmp(expr_env, 1);
}
bellard authored
2115
/* return 0 if OK, -1 if not found, -2 if no CPU defined */
bellard authored
2116
static int get_monitor_def(target_long *pval, const char *name)
2117
{
2118
    const MonitorDef *md;
bellard authored
2119
2120
    void *ptr;
2121
2122
2123
    for(md = monitor_defs; md->name != NULL; md++) {
        if (compare_cmd(name, md->name)) {
            if (md->get_value) {
2124
                *pval = md->get_value(md, md->offset);
2125
            } else {
bellard authored
2126
2127
2128
2129
                CPUState *env = mon_get_cpu();
                if (!env)
                    return -2;
                ptr = (uint8_t *)env + md->offset;
bellard authored
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
                switch(md->type) {
                case MD_I32:
                    *pval = *(int32_t *)ptr;
                    break;
                case MD_TLONG:
                    *pval = *(target_long *)ptr;
                    break;
                default:
                    *pval = 0;
                    break;
                }
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
            }
            return 0;
        }
    }
    return -1;
}

static void next(void)
{
    if (pch != '\0') {
        pch++;
2152
        while (qemu_isspace(*pch))
2153
2154
2155
2156
            pch++;
    }
}
2157
static int64_t expr_sum(Monitor *mon);
2158
2159
static int64_t expr_unary(Monitor *mon)
2160
{
blueswir1 authored
2161
    int64_t n;
2162
    char *p;
bellard authored
2163
    int ret;
2164
2165
2166
2167

    switch(*pch) {
    case '+':
        next();
2168
        n = expr_unary(mon);
2169
2170
2171
        break;
    case '-':
        next();
2172
        n = -expr_unary(mon);
2173
2174
2175
        break;
    case '~':
        next();
2176
        n = ~expr_unary(mon);
2177
2178
2179
        break;
    case '(':
        next();
2180
        n = expr_sum(mon);
2181
        if (*pch != ')') {
2182
            expr_error(mon, "')' expected");
2183
2184
2185
        }
        next();
        break;
bellard authored
2186
2187
2188
    case '\'':
        pch++;
        if (*pch == '\0')
2189
            expr_error(mon, "character constant expected");
bellard authored
2190
2191
2192
        n = *pch;
        pch++;
        if (*pch != '\'')
2193
            expr_error(mon, "missing terminating \' character");
bellard authored
2194
2195
        next();
        break;
2196
2197
2198
    case '$':
        {
            char buf[128], *q;
2199
            target_long reg=0;
2200
2201
2202
2203
2204
2205
            pch++;
            q = buf;
            while ((*pch >= 'a' && *pch <= 'z') ||
                   (*pch >= 'A' && *pch <= 'Z') ||
                   (*pch >= '0' && *pch <= '9') ||
2206
                   *pch == '_' || *pch == '.') {
2207
2208
2209
2210
                if ((q - buf) < sizeof(buf) - 1)
                    *q++ = *pch;
                pch++;
            }
2211
            while (qemu_isspace(*pch))
2212
2213
                pch++;
            *q = 0;
2214
            ret = get_monitor_def(&reg, buf);
bellard authored
2215
            if (ret == -1)
2216
                expr_error(mon, "unknown register");
2217
            else if (ret == -2)
2218
                expr_error(mon, "no cpu defined");
2219
            n = reg;
2220
2221
2222
        }
        break;
    case '\0':
2223
        expr_error(mon, "unexpected end of expression");
2224
2225
2226
        n = 0;
        break;
    default:
2227
#if TARGET_PHYS_ADDR_BITS > 32
bellard authored
2228
2229
        n = strtoull(pch, &p, 0);
#else
2230
        n = strtoul(pch, &p, 0);
bellard authored
2231
#endif
2232
        if (pch == p) {
2233
            expr_error(mon, "invalid char in expression");
2234
2235
        }
        pch = p;
2236
        while (qemu_isspace(*pch))
2237
2238
2239
2240
2241
2242
2243
            pch++;
        break;
    }
    return n;
}
2244
static int64_t expr_prod(Monitor *mon)
2245
{
blueswir1 authored
2246
    int64_t val, val2;
bellard authored
2247
    int op;
2248
2249
    val = expr_unary(mon);
2250
2251
2252
2253
2254
    for(;;) {
        op = *pch;
        if (op != '*' && op != '/' && op != '%')
            break;
        next();
2255
        val2 = expr_unary(mon);
2256
2257
2258
2259
2260
2261
2262
        switch(op) {
        default:
        case '*':
            val *= val2;
            break;
        case '/':
        case '%':
2263
            if (val2 == 0)
2264
                expr_error(mon, "division by zero");
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
            if (op == '/')
                val /= val2;
            else
                val %= val2;
            break;
        }
    }
    return val;
}
2275
static int64_t expr_logic(Monitor *mon)
2276
{
blueswir1 authored
2277
    int64_t val, val2;
bellard authored
2278
    int op;
2279
2280
    val = expr_prod(mon);
2281
2282
2283
2284
2285
    for(;;) {
        op = *pch;
        if (op != '&' && op != '|' && op != '^')
            break;
        next();
2286
        val2 = expr_prod(mon);
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
        switch(op) {
        default:
        case '&':
            val &= val2;
            break;
        case '|':
            val |= val2;
            break;
        case '^':
            val ^= val2;
            break;
        }
    }
    return val;
}
2303
static int64_t expr_sum(Monitor *mon)
2304
{
blueswir1 authored
2305
    int64_t val, val2;
bellard authored
2306
    int op;
2307
2308
    val = expr_logic(mon);
2309
2310
2311
2312
2313
    for(;;) {
        op = *pch;
        if (op != '+' && op != '-')
            break;
        next();
2314
        val2 = expr_logic(mon);
2315
2316
2317
2318
2319
2320
2321
2322
        if (op == '+')
            val += val2;
        else
            val -= val2;
    }
    return val;
}
2323
static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2324
2325
2326
2327
2328
2329
{
    pch = *pp;
    if (setjmp(expr_env)) {
        *pp = pch;
        return -1;
    }
2330
    while (qemu_isspace(*pch))
2331
        pch++;
2332
    *pval = expr_sum(mon);
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
    *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
2343
    q = buf;
2344
    p = *pp;
2345
    while (qemu_isspace(*p))
2346
2347
2348
        p++;
    if (*p == '\0') {
    fail:
bellard authored
2349
        *q = '\0';
2350
2351
2352
2353
2354
2355
2356
2357
2358
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
        *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
2385
            qemu_printf("unterminated string\n");
2386
2387
2388
2389
            goto fail;
        }
        p++;
    } else {
2390
        while (*p != '\0' && !qemu_isspace(*p)) {
2391
2392
2393
2394
2395
2396
            if ((q - buf) < buf_size - 1) {
                *q++ = *p;
            }
            p++;
        }
    }
bellard authored
2397
    *q = '\0';
2398
2399
2400
2401
    *pp = p;
    return 0;
}
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
/*
 * 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;
}
2428
2429
2430
2431
2432
static int default_fmt_format = 'x';
static int default_fmt_size = 4;

#define MAX_ARGS 16
2433
static void monitor_handle_command(Monitor *mon, const char *cmdline)
2434
{
2435
2436
    const char *p, *typestr;
    int c, nb_args, i, has_arg;
2437
    const mon_cmd_t *cmd;
2438
2439
2440
2441
    char cmdname[256];
    char buf[1024];
    void *str_allocated[MAX_ARGS];
    void *args[MAX_ARGS];
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
    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);
bellard authored
2454
2455

#ifdef DEBUG
2456
    monitor_printf(mon, "command='%s'\n", cmdline);
bellard authored
2457
#endif
2458
2459
    /* extract the command name */
2460
2461
    p = get_command_name(cmdline, cmdname, sizeof(cmdname));
    if (!p)
2462
        return;
2463
2464
    /* find the command */
2465
    for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
2466
        if (compare_cmd(cmdname, cmd->name))
2467
2468
2469
2470
2471
2472
            break;
    }

    if (cmd->name == NULL) {
        monitor_printf(mon, "unknown command: '%s'\n", cmdname);
        return;
2473
2474
2475
2476
    }

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

    switch(nb_args) {
    case 0:
2710
        handler_0 = cmd->handler;
2711
        handler_0(mon);
2712
2713
        break;
    case 1:
2714
        handler_1 = cmd->handler;
2715
        handler_1(mon, args[0]);
2716
2717
        break;
    case 2:
2718
        handler_2 = cmd->handler;
2719
        handler_2(mon, args[0], args[1]);
2720
2721
        break;
    case 3:
2722
        handler_3 = cmd->handler;
2723
        handler_3(mon, args[0], args[1], args[2]);
2724
2725
        break;
    case 4:
2726
        handler_4 = cmd->handler;
2727
        handler_4(mon, args[0], args[1], args[2], args[3]);
2728
2729
        break;
    case 5:
2730
        handler_5 = cmd->handler;
2731
        handler_5(mon, args[0], args[1], args[2], args[3], args[4]);
2732
        break;
bellard authored
2733
    case 6:
2734
        handler_6 = cmd->handler;
2735
        handler_6(mon, args[0], args[1], args[2], args[3], args[4], args[5]);
bellard authored
2736
        break;
2737
    case 7:
2738
        handler_7 = cmd->handler;
2739
2740
        handler_7(mon, args[0], args[1], args[2], args[3], args[4], args[5],
                  args[6]);
2741
        break;
2742
    default:
2743
        monitor_printf(mon, "unsupported number of arguments: %d\n", nb_args);
2744
        goto fail;
bellard authored
2745
    }
2746
2747
2748
 fail:
    for(i = 0; i < MAX_ARGS; i++)
        qemu_free(str_allocated[i]);
bellard authored
2749
2750
}
bellard authored
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
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))) {
2769
            readline_add_completion(cur_mon->rs, cmd);
bellard authored
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
        }
        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;
2786
    p = strrchr(input, '/');
bellard authored
2787
2788
2789
    if (!p) {
        input_path_len = 0;
        pstrcpy(file_prefix, sizeof(file_prefix), input);
2790
        pstrcpy(path, sizeof(path), ".");
bellard authored
2791
2792
2793
2794
2795
2796
2797
2798
2799
    } 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
2800
2801
    monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
                   input, path, file_prefix);
bellard authored
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
#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);
2813
2814
2815
            if (input_path_len < sizeof(file))
                pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
                        d->d_name);
bellard authored
2816
2817
2818
2819
2820
            /* 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))
2821
                pstrcat(file, sizeof(file), "/");
2822
            readline_add_completion(cur_mon->rs, file);
bellard authored
2823
2824
2825
2826
2827
        }
    }
    closedir(ffs);
}
2828
static void block_completion_it(void *opaque, BlockDriverState *bs)
bellard authored
2829
{
2830
    const char *name = bdrv_get_device_name(bs);
bellard authored
2831
2832
2833
2834
    const char *input = opaque;

    if (input[0] == '\0' ||
        !strncmp(name, (char *)input, strlen(input))) {
2835
        readline_add_completion(cur_mon->rs, name);
bellard authored
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
    }
}

/* 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(;;) {
2850
        while (qemu_isspace(*p))
bellard authored
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
            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;
}
2865
static void monitor_find_completion(const char *cmdline)
bellard authored
2866
2867
2868
2869
2870
{
    const char *cmdname;
    char *args[MAX_ARGS];
    int nb_args, i, len;
    const char *ptype, *str;
2871
    const mon_cmd_t *cmd;
2872
    const KeyDef *key;
bellard authored
2873
2874
2875
2876

    parse_cmdline(cmdline, &nb_args, args);
#ifdef DEBUG_COMPLETION
    for(i = 0; i < nb_args; i++) {
2877
        monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
bellard authored
2878
2879
2880
2881
2882
2883
    }
#endif

    /* if the line ends with a space, it means we want to complete the
       next arg */
    len = strlen(cmdline);
2884
    if (len > 0 && qemu_isspace(cmdline[len - 1])) {
bellard authored
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
        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];
2895
        readline_set_completion_index(cur_mon->rs, strlen(cmdname));
2896
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
bellard authored
2897
2898
2899
2900
            cmd_completion(cmdname, cmd->name);
        }
    } else {
        /* find the command */
2901
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
bellard authored
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
            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 */
2919
            readline_set_completion_index(cur_mon->rs, strlen(str));
bellard authored
2920
2921
2922
2923
            file_completion(str);
            break;
        case 'B':
            /* block device name completion */
2924
            readline_set_completion_index(cur_mon->rs, strlen(str));
bellard authored
2925
2926
            bdrv_iterate(block_completion_it, (void *)str);
            break;
bellard authored
2927
2928
2929
        case 's':
            /* XXX: more generic ? */
            if (!strcmp(cmd->name, "info")) {
2930
                readline_set_completion_index(cur_mon->rs, strlen(str));
bellard authored
2931
2932
2933
                for(cmd = info_cmds; cmd->name != NULL; cmd++) {
                    cmd_completion(str, cmd->name);
                }
2934
            } else if (!strcmp(cmd->name, "sendkey")) {
2935
2936
2937
                char *sep = strrchr(str, '-');
                if (sep)
                    str = sep + 1;
2938
                readline_set_completion_index(cur_mon->rs, strlen(str));
2939
2940
2941
                for(key = key_defs; key->name != NULL; key++) {
                    cmd_completion(str, key->name);
                }
2942
2943
2944
2945
2946
            } 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
2947
2948
            }
            break;
bellard authored
2949
2950
2951
2952
2953
2954
2955
2956
        default:
            break;
        }
    }
    for(i = 0; i < nb_args; i++)
        qemu_free(args[i]);
}
2957
static int monitor_can_read(void *opaque)
bellard authored
2958
{
2959
2960
2961
    Monitor *mon = opaque;

    return (mon->suspend_cnt == 0) ? 128 : 0;
bellard authored
2962
2963
}
2964
static void monitor_read(void *opaque, const uint8_t *buf, int size)
bellard authored
2965
{
2966
    Monitor *old_mon = cur_mon;
2967
    int i;
2968
2969
2970
    cur_mon = opaque;
2971
2972
2973
2974
2975
2976
2977
2978
2979
    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
2980
2981
2982
    cur_mon = old_mon;
}
2983
2984
static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
2985
{
2986
    monitor_suspend(mon);
2987
    monitor_handle_command(mon, cmdline);
2988
    monitor_resume(mon);
2989
2990
}
2991
int monitor_suspend(Monitor *mon)
2992
{
2993
2994
    if (!mon->rs)
        return -ENOTTY;
2995
    mon->suspend_cnt++;
2996
    return 0;
2997
2998
}
2999
void monitor_resume(Monitor *mon)
3000
{
3001
3002
    if (!mon->rs)
        return;
3003
3004
    if (--mon->suspend_cnt == 0)
        readline_show_prompt(mon->rs);
3005
3006
}
3007
static void monitor_event(void *opaque, int event)
3008
{
3009
3010
    Monitor *mon = opaque;
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
    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;
3024
3025
3026
3027
3028
3029
3030
3031
    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;
    }
3032
3033
}
3034
3035
3036
3037
3038
3039
3040
3041
3042

/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 *  tab-width: 8
 * End:
 */
3043
void monitor_init(CharDriverState *chr, int flags)
3044
{
3045
    static int is_first_init = 1;
3046
    Monitor *mon;
3047
3048

    if (is_first_init) {
3049
        key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
3050
3051
        is_first_init = 0;
    }
3052
3053

    mon = qemu_mallocz(sizeof(*mon));
3054
3055
    mon->chr = chr;
3056
    mon->flags = flags;
3057
3058
    if (mon->chr->focus != 0)
        mon->suspend_cnt = 1; /* mux'ed monitors start suspended */
3059
3060
3061
3062
    if (flags & MONITOR_USE_READLINE) {
        mon->rs = readline_init(mon, monitor_find_completion);
        monitor_read_command(mon, 0);
    }
3063
3064
3065
    qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event,
                          mon);
3066
3067

    LIST_INSERT_HEAD(&mon_list, mon, entry);
3068
    if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
3069
        cur_mon = mon;
3070
3071
}
3072
static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
bellard authored
3073
{
3074
3075
    BlockDriverState *bs = opaque;
    int ret = 0;
bellard authored
3076
3077
    if (bdrv_set_key(bs, password) != 0) {
3078
        monitor_printf(mon, "invalid password\n");
3079
        ret = -EPERM;
bellard authored
3080
    }
3081
3082
    if (mon->password_completion_cb)
        mon->password_completion_cb(mon->password_opaque, ret);
3083
3084
    monitor_read_command(mon, 1);
bellard authored
3085
}
3086
3087
void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
3088
3089
                                 BlockDriverCompletionFunc *completion_cb,
                                 void *opaque)
3090
{
3091
3092
    int err;
3093
3094
3095
3096
3097
    if (!bdrv_key_required(bs)) {
        if (completion_cb)
            completion_cb(opaque, 0);
        return;
    }
3098
3099
3100
    monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
                   bdrv_get_encrypted_filename(bs));
3101
3102
3103
    mon->password_completion_cb = completion_cb;
    mon->password_opaque = opaque;
3104
3105
3106
3107
3108
    err = monitor_read_password(mon, bdrv_password_cb, bs);

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