Statistics
| Branch: | Revision:

root / monitor.c @ 2313086a

History | View | Annotate | Download (82.4 kB)

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

    
48
//#define DEBUG
49
//#define DEBUG_COMPLETION
50

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

    
65
typedef struct mon_cmd_t {
66
    const char *name;
67
    const char *args_type;
68
    void *handler;
69
    const char *params;
70
    const char *help;
71
} mon_cmd_t;
72

    
73
struct Monitor {
74
    CharDriverState *chr;
75
    int flags;
76
    int suspend_cnt;
77
    uint8_t outbuf[1024];
78
    int outbuf_index;
79
    ReadLineState *rs;
80
    CPUState *mon_cpu;
81
    BlockDriverCompletionFunc *password_completion_cb;
82
    void *password_opaque;
83
    LIST_ENTRY(Monitor) entry;
84
};
85

    
86
static LIST_HEAD(mon_list, Monitor) mon_list;
87

    
88
static const mon_cmd_t mon_cmds[];
89
static const mon_cmd_t info_cmds[];
90

    
91
Monitor *cur_mon = NULL;
92

    
93
static void monitor_command_cb(Monitor *mon, const char *cmdline,
94
                               void *opaque);
95

    
96
static void monitor_read_command(Monitor *mon, int show_prompt)
97
{
98
    readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
99
    if (show_prompt)
100
        readline_show_prompt(mon->rs);
101
}
102

    
103
static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
104
                                 void *opaque)
105
{
106
    if (mon->rs) {
107
        readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
108
        /* prompt is printed on return from the command handler */
109
        return 0;
110
    } else {
111
        monitor_printf(mon, "terminal does not support password prompting\n");
112
        return -ENOTTY;
113
    }
114
}
115

    
116
void monitor_flush(Monitor *mon)
117
{
118
    if (mon && mon->outbuf_index != 0 && mon->chr->focus == 0) {
119
        qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
120
        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
    if (!mon)
130
        return;
131

    
132
    for(;;) {
133
        c = *str++;
134
        if (c == '\0')
135
            break;
136
        if (c == '\n')
137
            mon->outbuf[mon->outbuf_index++] = '\r';
138
        mon->outbuf[mon->outbuf_index++] = c;
139
        if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
140
            || c == '\n')
141
            monitor_flush(mon);
142
    }
143
}
144

    
145
void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
146
{
147
    char buf[4096];
148
    vsnprintf(buf, sizeof(buf), fmt, ap);
149
    monitor_puts(mon, buf);
150
}
151

    
152
void monitor_printf(Monitor *mon, const char *fmt, ...)
153
{
154
    va_list ap;
155
    va_start(ap, fmt);
156
    monitor_vprintf(mon, fmt, ap);
157
    va_end(ap);
158
}
159

    
160
void monitor_print_filename(Monitor *mon, const char *filename)
161
{
162
    int i;
163

    
164
    for (i = 0; filename[i]; i++) {
165
        switch (filename[i]) {
166
        case ' ':
167
        case '"':
168
        case '\\':
169
            monitor_printf(mon, "\\%c", filename[i]);
170
            break;
171
        case '\t':
172
            monitor_printf(mon, "\\t");
173
            break;
174
        case '\r':
175
            monitor_printf(mon, "\\r");
176
            break;
177
        case '\n':
178
            monitor_printf(mon, "\\n");
179
            break;
180
        default:
181
            monitor_printf(mon, "%c", filename[i]);
182
            break;
183
        }
184
    }
185
}
186

    
187
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
188
{
189
    va_list ap;
190
    va_start(ap, fmt);
191
    monitor_vprintf((Monitor *)stream, fmt, ap);
192
    va_end(ap);
193
    return 0;
194
}
195

    
196
static int compare_cmd(const char *name, const char *list)
197
{
198
    const char *p, *pstart;
199
    int len;
200
    len = strlen(name);
201
    p = list;
202
    for(;;) {
203
        pstart = p;
204
        p = strchr(p, '|');
205
        if (!p)
206
            p = pstart + strlen(pstart);
207
        if ((p - pstart) == len && !memcmp(pstart, name, len))
208
            return 1;
209
        if (*p == '\0')
210
            break;
211
        p++;
212
    }
213
    return 0;
214
}
215

    
216
static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
217
                          const char *prefix, const char *name)
218
{
219
    const mon_cmd_t *cmd;
220

    
221
    for(cmd = cmds; cmd->name != NULL; cmd++) {
222
        if (!name || !strcmp(name, cmd->name))
223
            monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
224
                           cmd->params, cmd->help);
225
    }
226
}
227

    
228
static void help_cmd(Monitor *mon, const char *name)
229
{
230
    if (name && !strcmp(name, "info")) {
231
        help_cmd_dump(mon, info_cmds, "info ", NULL);
232
    } else {
233
        help_cmd_dump(mon, mon_cmds, "", name);
234
        if (name && !strcmp(name, "log")) {
235
            const CPULogItem *item;
236
            monitor_printf(mon, "Log items (comma separated):\n");
237
            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
        }
242
    }
243
}
244

    
245
static void do_commit(Monitor *mon, const char *device)
246
{
247
    int i, all_devices;
248

    
249
    all_devices = !strcmp(device, "all");
250
    for (i = 0; i < nb_drives; i++) {
251
            if (all_devices ||
252
                !strcmp(bdrv_get_device_name(drives_table[i].bdrv), device))
253
                bdrv_commit(drives_table[i].bdrv);
254
    }
255
}
256

    
257
static void do_info(Monitor *mon, const char *item)
258
{
259
    const mon_cmd_t *cmd;
260
    void (*handler)(Monitor *);
261

    
262
    if (!item)
263
        goto help;
264
    for(cmd = info_cmds; cmd->name != NULL; cmd++) {
265
        if (compare_cmd(item, cmd->name))
266
            goto found;
267
    }
268
 help:
269
    help_cmd(mon, "info");
270
    return;
271
 found:
272
    handler = cmd->handler;
273
    handler(mon);
274
}
275

    
276
static void do_info_version(Monitor *mon)
277
{
278
    monitor_printf(mon, "%s\n", QEMU_VERSION QEMU_PKGVERSION);
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
    monitor_printf(mon, "HPET is %s by QEMU\n",
291
                   (no_hpet) ? "disabled" : "enabled");
292
}
293
#endif
294

    
295
static void do_info_uuid(Monitor *mon)
296
{
297
    monitor_printf(mon, UUID_FMT "\n", qemu_uuid[0], qemu_uuid[1],
298
                   qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
299
                   qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
300
                   qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
301
                   qemu_uuid[14], qemu_uuid[15]);
302
}
303

    
304
/* get the current CPU defined by the user */
305
static int mon_set_cpu(int cpu_index)
306
{
307
    CPUState *env;
308

    
309
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
310
        if (env->cpu_index == cpu_index) {
311
            cur_mon->mon_cpu = env;
312
            return 0;
313
        }
314
    }
315
    return -1;
316
}
317

    
318
static CPUState *mon_get_cpu(void)
319
{
320
    if (!cur_mon->mon_cpu) {
321
        mon_set_cpu(0);
322
    }
323
    cpu_synchronize_state(cur_mon->mon_cpu, 0);
324
    return cur_mon->mon_cpu;
325
}
326

    
327
static void do_info_registers(Monitor *mon)
328
{
329
    CPUState *env;
330
    env = mon_get_cpu();
331
    if (!env)
332
        return;
333
#ifdef TARGET_I386
334
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
335
                   X86_DUMP_FPU);
336
#else
337
    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
338
                   0);
339
#endif
340
}
341

    
342
static void do_info_cpus(Monitor *mon)
343
{
344
    CPUState *env;
345

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

    
349
    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);
354
#if defined(TARGET_I386)
355
        monitor_printf(mon, " pc=0x" TARGET_FMT_lx,
356
                       env->eip + env->segs[R_CS].base);
357
#elif defined(TARGET_PPC)
358
        monitor_printf(mon, " nip=0x" TARGET_FMT_lx, env->nip);
359
#elif defined(TARGET_SPARC)
360
        monitor_printf(mon, " pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx,
361
                       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
            monitor_printf(mon, " (halted)");
367
        monitor_printf(mon, "\n");
368
    }
369
}
370

    
371
static void do_cpu_set(Monitor *mon, int index)
372
{
373
    if (mon_set_cpu(index) < 0)
374
        monitor_printf(mon, "Invalid CPU index\n");
375
}
376

    
377
static void do_info_jit(Monitor *mon)
378
{
379
    dump_exec_info((FILE *)mon, monitor_fprintf);
380
}
381

    
382
static void do_info_history(Monitor *mon)
383
{
384
    int i;
385
    const char *str;
386

    
387
    if (!mon->rs)
388
        return;
389
    i = 0;
390
    for(;;) {
391
        str = readline_get_history(mon->rs, i);
392
        if (!str)
393
            break;
394
        monitor_printf(mon, "%d: '%s'\n", i, str);
395
        i++;
396
    }
397
}
398

    
399
#if defined(TARGET_PPC)
400
/* XXX: not implemented in other targets */
401
static void do_info_cpu_stats(Monitor *mon)
402
{
403
    CPUState *env;
404

    
405
    env = mon_get_cpu();
406
    cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
407
}
408
#endif
409

    
410
static void do_quit(Monitor *mon)
411
{
412
    exit(0);
413
}
414

    
415
static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
416
{
417
    if (bdrv_is_inserted(bs)) {
418
        if (!force) {
419
            if (!bdrv_is_removable(bs)) {
420
                monitor_printf(mon, "device is not removable\n");
421
                return -1;
422
            }
423
            if (bdrv_is_locked(bs)) {
424
                monitor_printf(mon, "device is locked\n");
425
                return -1;
426
            }
427
        }
428
        bdrv_close(bs);
429
    }
430
    return 0;
431
}
432

    
433
static void do_eject(Monitor *mon, int force, const char *filename)
434
{
435
    BlockDriverState *bs;
436

    
437
    bs = bdrv_find(filename);
438
    if (!bs) {
439
        monitor_printf(mon, "device not found\n");
440
        return;
441
    }
442
    eject_device(mon, bs, force);
443
}
444

    
445
static void do_change_block(Monitor *mon, const char *device,
446
                            const char *filename, const char *fmt)
447
{
448
    BlockDriverState *bs;
449
    BlockDriver *drv = NULL;
450

    
451
    bs = bdrv_find(device);
452
    if (!bs) {
453
        monitor_printf(mon, "device not found\n");
454
        return;
455
    }
456
    if (fmt) {
457
        drv = bdrv_find_format(fmt);
458
        if (!drv) {
459
            monitor_printf(mon, "invalid format %s\n", fmt);
460
            return;
461
        }
462
    }
463
    if (eject_device(mon, bs, 0) < 0)
464
        return;
465
    bdrv_open2(bs, filename, 0, drv);
466
    monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
467
}
468

    
469
static void change_vnc_password_cb(Monitor *mon, const char *password,
470
                                   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);
476
}
477

    
478
static void do_change_vnc(Monitor *mon, const char *target, const char *arg)
479
{
480
    if (strcmp(target, "passwd") == 0 ||
481
        strcmp(target, "password") == 0) {
482
        if (arg) {
483
            char password[9];
484
            strncpy(password, arg, sizeof(password));
485
            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
static void do_change(Monitor *mon, const char *device, const char *target,
497
                      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)
512
{
513
    cpu_set_log_filename(filename);
514
}
515

    
516
static void do_log(Monitor *mon, const char *items)
517
{
518
    int mask;
519

    
520
    if (!strcmp(items, "none")) {
521
        mask = 0;
522
    } else {
523
        mask = cpu_str_to_log_mask(items);
524
        if (!mask) {
525
            help_cmd(mon, "log");
526
            return;
527
        }
528
    }
529
    cpu_set_log(mask);
530
}
531

    
532
static void do_singlestep(Monitor *mon, const char *option)
533
{
534
    if (!option || !strcmp(option, "on")) {
535
        singlestep = 1;
536
    } else if (!strcmp(option, "off")) {
537
        singlestep = 0;
538
    } else {
539
        monitor_printf(mon, "unexpected option %s\n", option);
540
    }
541
}
542

    
543
static void do_stop(Monitor *mon)
544
{
545
    vm_stop(EXCP_INTERRUPT);
546
}
547

    
548
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
549

    
550
struct bdrv_iterate_context {
551
    Monitor *mon;
552
    int err;
553
};
554

    
555
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
static void bdrv_key_cb(void *opaque, int err)
566
{
567
    Monitor *mon = opaque;
568

    
569
    /* another key was set successfully, retry to continue */
570
    if (!err)
571
        do_cont(mon);
572
}
573

    
574
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
575
{
576
    struct bdrv_iterate_context *context = opaque;
577

    
578
    if (!context->err && bdrv_key_required(bs)) {
579
        context->err = -EBUSY;
580
        monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
581
                                    context->mon);
582
    }
583
}
584

    
585
static void do_gdbserver(Monitor *mon, const char *device)
586
{
587
    if (!device)
588
        device = "tcp::" DEFAULT_GDBSTUB_PORT;
589
    if (gdbserver_start(device) < 0) {
590
        monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
591
                       device);
592
    } else if (strcmp(device, "none") == 0) {
593
        monitor_printf(mon, "Disabled gdbserver\n");
594
    } else {
595
        monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
596
                       device);
597
    }
598
}
599

    
600
static void do_watchdog_action(Monitor *mon, const char *action)
601
{
602
    if (select_watchdog_action(action) == -1) {
603
        monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
604
    }
605
}
606

    
607
static void monitor_printc(Monitor *mon, int c)
608
{
609
    monitor_printf(mon, "'");
610
    switch(c) {
611
    case '\'':
612
        monitor_printf(mon, "\\'");
613
        break;
614
    case '\\':
615
        monitor_printf(mon, "\\\\");
616
        break;
617
    case '\n':
618
        monitor_printf(mon, "\\n");
619
        break;
620
    case '\r':
621
        monitor_printf(mon, "\\r");
622
        break;
623
    default:
624
        if (c >= 32 && c <= 126) {
625
            monitor_printf(mon, "%c", c);
626
        } else {
627
            monitor_printf(mon, "\\x%02x", c);
628
        }
629
        break;
630
    }
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
{
637
    CPUState *env;
638
    int nb_per_line, l, line_size, i, max_digits, len;
639
    uint8_t buf[16];
640
    uint64_t v;
641

    
642
    if (format == 'i') {
643
        int flags;
644
        flags = 0;
645
        env = mon_get_cpu();
646
        if (!env && !is_physical)
647
            return;
648
#ifdef TARGET_I386
649
        if (wsize == 2) {
650
            flags = 1;
651
        } else if (wsize == 4) {
652
            flags = 0;
653
        } else {
654
            /* as default we use the current CS size */
655
            flags = 0;
656
            if (env) {
657
#ifdef TARGET_X86_64
658
                if ((env->efer & MSR_EFER_LMA) &&
659
                    (env->segs[R_CS].flags & DESC_L_MASK))
660
                    flags = 2;
661
                else
662
#endif
663
                if (!(env->segs[R_CS].flags & DESC_B_MASK))
664
                    flags = 1;
665
            }
666
        }
667
#endif
668
        monitor_disas(mon, env, addr, count, is_physical, flags);
669
        return;
670
    }
671

    
672
    len = wsize * count;
673
    if (wsize == 1)
674
        line_size = 8;
675
    else
676
        line_size = 16;
677
    nb_per_line = line_size / wsize;
678
    max_digits = 0;
679

    
680
    switch(format) {
681
    case 'o':
682
        max_digits = (wsize * 8 + 2) / 3;
683
        break;
684
    default:
685
    case 'x':
686
        max_digits = (wsize * 8) / 4;
687
        break;
688
    case 'u':
689
    case 'd':
690
        max_digits = (wsize * 8 * 10 + 32) / 33;
691
        break;
692
    case 'c':
693
        wsize = 1;
694
        break;
695
    }
696

    
697
    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
        l = len;
703
        if (l > line_size)
704
            l = line_size;
705
        if (is_physical) {
706
            cpu_physical_memory_rw(addr, buf, l, 0);
707
        } else {
708
            env = mon_get_cpu();
709
            if (!env)
710
                break;
711
            if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
712
                monitor_printf(mon, " Cannot access memory\n");
713
                break;
714
            }
715
        }
716
        i = 0;
717
        while (i < l) {
718
            switch(wsize) {
719
            default:
720
            case 1:
721
                v = ldub_raw(buf + i);
722
                break;
723
            case 2:
724
                v = lduw_raw(buf + i);
725
                break;
726
            case 4:
727
                v = (uint32_t)ldl_raw(buf + i);
728
                break;
729
            case 8:
730
                v = ldq_raw(buf + i);
731
                break;
732
            }
733
            monitor_printf(mon, " ");
734
            switch(format) {
735
            case 'o':
736
                monitor_printf(mon, "%#*" PRIo64, max_digits, v);
737
                break;
738
            case 'x':
739
                monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
740
                break;
741
            case 'u':
742
                monitor_printf(mon, "%*" PRIu64, max_digits, v);
743
                break;
744
            case 'd':
745
                monitor_printf(mon, "%*" PRId64, max_digits, v);
746
                break;
747
            case 'c':
748
                monitor_printc(mon, v);
749
                break;
750
            }
751
            i += wsize;
752
        }
753
        monitor_printf(mon, "\n");
754
        addr += l;
755
        len -= l;
756
    }
757
}
758

    
759
#if TARGET_LONG_BITS == 64
760
#define GET_TLONG(h, l) (((uint64_t)(h) << 32) | (l))
761
#else
762
#define GET_TLONG(h, l) (l)
763
#endif
764

    
765
static void do_memory_dump(Monitor *mon, int count, int format, int size,
766
                           uint32_t addrh, uint32_t addrl)
767
{
768
    target_long addr = GET_TLONG(addrh, addrl);
769
    memory_dump(mon, count, format, size, addr, 0);
770
}
771

    
772
#if TARGET_PHYS_ADDR_BITS > 32
773
#define GET_TPHYSADDR(h, l) (((uint64_t)(h) << 32) | (l))
774
#else
775
#define GET_TPHYSADDR(h, l) (l)
776
#endif
777

    
778
static void do_physical_memory_dump(Monitor *mon, int count, int format,
779
                                    int size, uint32_t addrh, uint32_t addrl)
780

    
781
{
782
    target_phys_addr_t addr = GET_TPHYSADDR(addrh, addrl);
783
    memory_dump(mon, count, format, size, addr, 1);
784
}
785

    
786
static void do_print(Monitor *mon, int count, int format, int size,
787
                     unsigned int valh, unsigned int vall)
788
{
789
    target_phys_addr_t val = GET_TPHYSADDR(valh, vall);
790
#if TARGET_PHYS_ADDR_BITS == 32
791
    switch(format) {
792
    case 'o':
793
        monitor_printf(mon, "%#o", val);
794
        break;
795
    case 'x':
796
        monitor_printf(mon, "%#x", val);
797
        break;
798
    case 'u':
799
        monitor_printf(mon, "%u", val);
800
        break;
801
    default:
802
    case 'd':
803
        monitor_printf(mon, "%d", val);
804
        break;
805
    case 'c':
806
        monitor_printc(mon, val);
807
        break;
808
    }
809
#else
810
    switch(format) {
811
    case 'o':
812
        monitor_printf(mon, "%#" PRIo64, val);
813
        break;
814
    case 'x':
815
        monitor_printf(mon, "%#" PRIx64, val);
816
        break;
817
    case 'u':
818
        monitor_printf(mon, "%" PRIu64, val);
819
        break;
820
    default:
821
    case 'd':
822
        monitor_printf(mon, "%" PRId64, val);
823
        break;
824
    case 'c':
825
        monitor_printc(mon, val);
826
        break;
827
    }
828
#endif
829
    monitor_printf(mon, "\n");
830
}
831

    
832
static void do_memory_save(Monitor *mon, unsigned int valh, unsigned int vall,
833
                           uint32_t size, const char *filename)
834
{
835
    FILE *f;
836
    target_long addr = GET_TLONG(valh, vall);
837
    uint32_t l;
838
    CPUState *env;
839
    uint8_t buf[1024];
840

    
841
    env = mon_get_cpu();
842
    if (!env)
843
        return;
844

    
845
    f = fopen(filename, "wb");
846
    if (!f) {
847
        monitor_printf(mon, "could not open '%s'\n", filename);
848
        return;
849
    }
850
    while (size != 0) {
851
        l = sizeof(buf);
852
        if (l > size)
853
            l = size;
854
        cpu_memory_rw_debug(env, addr, buf, l, 0);
855
        fwrite(buf, 1, l, f);
856
        addr += l;
857
        size -= l;
858
    }
859
    fclose(f);
860
}
861

    
862
static void do_physical_memory_save(Monitor *mon, unsigned int valh,
863
                                    unsigned int vall, uint32_t size,
864
                                    const char *filename)
865
{
866
    FILE *f;
867
    uint32_t l;
868
    uint8_t buf[1024];
869
    target_phys_addr_t addr = GET_TPHYSADDR(valh, vall); 
870

    
871
    f = fopen(filename, "wb");
872
    if (!f) {
873
        monitor_printf(mon, "could not open '%s'\n", filename);
874
        return;
875
    }
876
    while (size != 0) {
877
        l = sizeof(buf);
878
        if (l > size)
879
            l = size;
880
        cpu_physical_memory_rw(addr, buf, l, 0);
881
        fwrite(buf, 1, l, f);
882
        fflush(f);
883
        addr += l;
884
        size -= l;
885
    }
886
    fclose(f);
887
}
888

    
889
static void do_sum(Monitor *mon, uint32_t start, uint32_t size)
890
{
891
    uint32_t addr;
892
    uint8_t buf[1];
893
    uint16_t sum;
894

    
895
    sum = 0;
896
    for(addr = start; addr < (start + size); addr++) {
897
        cpu_physical_memory_rw(addr, buf, 1, 0);
898
        /* BSD sum algorithm ('sum' Unix command) */
899
        sum = (sum >> 1) | (sum << 15);
900
        sum += buf[0];
901
    }
902
    monitor_printf(mon, "%05d\n", sum);
903
}
904

    
905
typedef struct {
906
    int keycode;
907
    const char *name;
908
} KeyDef;
909

    
910
static const KeyDef key_defs[] = {
911
    { 0x2a, "shift" },
912
    { 0x36, "shift_r" },
913

    
914
    { 0x38, "alt" },
915
    { 0xb8, "alt_r" },
916
    { 0x64, "altgr" },
917
    { 0xe4, "altgr_r" },
918
    { 0x1d, "ctrl" },
919
    { 0x9d, "ctrl_r" },
920

    
921
    { 0xdd, "menu" },
922

    
923
    { 0x01, "esc" },
924

    
925
    { 0x02, "1" },
926
    { 0x03, "2" },
927
    { 0x04, "3" },
928
    { 0x05, "4" },
929
    { 0x06, "5" },
930
    { 0x07, "6" },
931
    { 0x08, "7" },
932
    { 0x09, "8" },
933
    { 0x0a, "9" },
934
    { 0x0b, "0" },
935
    { 0x0c, "minus" },
936
    { 0x0d, "equal" },
937
    { 0x0e, "backspace" },
938

    
939
    { 0x0f, "tab" },
940
    { 0x10, "q" },
941
    { 0x11, "w" },
942
    { 0x12, "e" },
943
    { 0x13, "r" },
944
    { 0x14, "t" },
945
    { 0x15, "y" },
946
    { 0x16, "u" },
947
    { 0x17, "i" },
948
    { 0x18, "o" },
949
    { 0x19, "p" },
950

    
951
    { 0x1c, "ret" },
952

    
953
    { 0x1e, "a" },
954
    { 0x1f, "s" },
955
    { 0x20, "d" },
956
    { 0x21, "f" },
957
    { 0x22, "g" },
958
    { 0x23, "h" },
959
    { 0x24, "j" },
960
    { 0x25, "k" },
961
    { 0x26, "l" },
962

    
963
    { 0x2c, "z" },
964
    { 0x2d, "x" },
965
    { 0x2e, "c" },
966
    { 0x2f, "v" },
967
    { 0x30, "b" },
968
    { 0x31, "n" },
969
    { 0x32, "m" },
970
    { 0x33, "comma" },
971
    { 0x34, "dot" },
972
    { 0x35, "slash" },
973

    
974
    { 0x37, "asterisk" },
975

    
976
    { 0x39, "spc" },
977
    { 0x3a, "caps_lock" },
978
    { 0x3b, "f1" },
979
    { 0x3c, "f2" },
980
    { 0x3d, "f3" },
981
    { 0x3e, "f4" },
982
    { 0x3f, "f5" },
983
    { 0x40, "f6" },
984
    { 0x41, "f7" },
985
    { 0x42, "f8" },
986
    { 0x43, "f9" },
987
    { 0x44, "f10" },
988
    { 0x45, "num_lock" },
989
    { 0x46, "scroll_lock" },
990

    
991
    { 0xb5, "kp_divide" },
992
    { 0x37, "kp_multiply" },
993
    { 0x4a, "kp_subtract" },
994
    { 0x4e, "kp_add" },
995
    { 0x9c, "kp_enter" },
996
    { 0x53, "kp_decimal" },
997
    { 0x54, "sysrq" },
998

    
999
    { 0x52, "kp_0" },
1000
    { 0x4f, "kp_1" },
1001
    { 0x50, "kp_2" },
1002
    { 0x51, "kp_3" },
1003
    { 0x4b, "kp_4" },
1004
    { 0x4c, "kp_5" },
1005
    { 0x4d, "kp_6" },
1006
    { 0x47, "kp_7" },
1007
    { 0x48, "kp_8" },
1008
    { 0x49, "kp_9" },
1009

    
1010
    { 0x56, "<" },
1011

    
1012
    { 0x57, "f11" },
1013
    { 0x58, "f12" },
1014

    
1015
    { 0xb7, "print" },
1016

    
1017
    { 0xc7, "home" },
1018
    { 0xc9, "pgup" },
1019
    { 0xd1, "pgdn" },
1020
    { 0xcf, "end" },
1021

    
1022
    { 0xcb, "left" },
1023
    { 0xc8, "up" },
1024
    { 0xd0, "down" },
1025
    { 0xcd, "right" },
1026

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

    
1049
static int get_keycode(const char *key)
1050
{
1051
    const KeyDef *p;
1052
    char *endp;
1053
    int ret;
1054

    
1055
    for(p = key_defs; p->name != NULL; p++) {
1056
        if (!strcmp(key, p->name))
1057
            return p->keycode;
1058
    }
1059
    if (strstart(key, "0x", NULL)) {
1060
        ret = strtoul(key, &endp, 0);
1061
        if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1062
            return ret;
1063
    }
1064
    return -1;
1065
}
1066

    
1067
#define MAX_KEYCODES 16
1068
static uint8_t keycodes[MAX_KEYCODES];
1069
static int nb_pending_keycodes;
1070
static QEMUTimer *key_timer;
1071

    
1072
static void release_keys(void *opaque)
1073
{
1074
    int keycode;
1075

    
1076
    while (nb_pending_keycodes > 0) {
1077
        nb_pending_keycodes--;
1078
        keycode = keycodes[nb_pending_keycodes];
1079
        if (keycode & 0x80)
1080
            kbd_put_keycode(0xe0);
1081
        kbd_put_keycode(keycode | 0x80);
1082
    }
1083
}
1084

    
1085
static void do_sendkey(Monitor *mon, const char *string, int has_hold_time,
1086
                       int hold_time)
1087
{
1088
    char keyname_buf[16];
1089
    char *separator;
1090
    int keyname_len, keycode, i;
1091

    
1092
    if (nb_pending_keycodes > 0) {
1093
        qemu_del_timer(key_timer);
1094
        release_keys(NULL);
1095
    }
1096
    if (!has_hold_time)
1097
        hold_time = 100;
1098
    i = 0;
1099
    while (1) {
1100
        separator = strchr(string, '-');
1101
        keyname_len = separator ? separator - string : strlen(string);
1102
        if (keyname_len > 0) {
1103
            pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1104
            if (keyname_len > sizeof(keyname_buf) - 1) {
1105
                monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1106
                return;
1107
            }
1108
            if (i == MAX_KEYCODES) {
1109
                monitor_printf(mon, "too many keys\n");
1110
                return;
1111
            }
1112
            keyname_buf[keyname_len] = 0;
1113
            keycode = get_keycode(keyname_buf);
1114
            if (keycode < 0) {
1115
                monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1116
                return;
1117
            }
1118
            keycodes[i++] = keycode;
1119
        }
1120
        if (!separator)
1121
            break;
1122
        string = separator + 1;
1123
    }
1124
    nb_pending_keycodes = i;
1125
    /* key down events */
1126
    for (i = 0; i < nb_pending_keycodes; i++) {
1127
        keycode = keycodes[i];
1128
        if (keycode & 0x80)
1129
            kbd_put_keycode(0xe0);
1130
        kbd_put_keycode(keycode & 0x7f);
1131
    }
1132
    /* delayed key up events */
1133
    qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
1134
                    muldiv64(ticks_per_sec, hold_time, 1000));
1135
}
1136

    
1137
static int mouse_button_state;
1138

    
1139
static void do_mouse_move(Monitor *mon, const char *dx_str, const char *dy_str,
1140
                          const char *dz_str)
1141
{
1142
    int dx, dy, dz;
1143
    dx = strtol(dx_str, NULL, 0);
1144
    dy = strtol(dy_str, NULL, 0);
1145
    dz = 0;
1146
    if (dz_str)
1147
        dz = strtol(dz_str, NULL, 0);
1148
    kbd_mouse_event(dx, dy, dz, mouse_button_state);
1149
}
1150

    
1151
static void do_mouse_button(Monitor *mon, int button_state)
1152
{
1153
    mouse_button_state = button_state;
1154
    kbd_mouse_event(0, 0, 0, mouse_button_state);
1155
}
1156

    
1157
static void do_ioport_read(Monitor *mon, int count, int format, int size,
1158
                           int addr, int has_index, int index)
1159
{
1160
    uint32_t val;
1161
    int suffix;
1162

    
1163
    if (has_index) {
1164
        cpu_outb(NULL, addr & 0xffff, index & 0xff);
1165
        addr++;
1166
    }
1167
    addr &= 0xffff;
1168

    
1169
    switch(size) {
1170
    default:
1171
    case 1:
1172
        val = cpu_inb(NULL, addr);
1173
        suffix = 'b';
1174
        break;
1175
    case 2:
1176
        val = cpu_inw(NULL, addr);
1177
        suffix = 'w';
1178
        break;
1179
    case 4:
1180
        val = cpu_inl(NULL, addr);
1181
        suffix = 'l';
1182
        break;
1183
    }
1184
    monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1185
                   suffix, addr, size * 2, val);
1186
}
1187

    
1188
/* boot_set handler */
1189
static QEMUBootSetHandler *qemu_boot_set_handler = NULL;
1190
static void *boot_opaque;
1191

    
1192
void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
1193
{
1194
    qemu_boot_set_handler = func;
1195
    boot_opaque = opaque;
1196
}
1197

    
1198
static void do_boot_set(Monitor *mon, const char *bootdevice)
1199
{
1200
    int res;
1201

    
1202
    if (qemu_boot_set_handler)  {
1203
        res = qemu_boot_set_handler(boot_opaque, bootdevice);
1204
        if (res == 0)
1205
            monitor_printf(mon, "boot device list now set to %s\n",
1206
                           bootdevice);
1207
        else
1208
            monitor_printf(mon, "setting boot device list failed with "
1209
                           "error %i\n", res);
1210
    } else {
1211
        monitor_printf(mon, "no function defined to set boot device list for "
1212
                       "this architecture\n");
1213
    }
1214
}
1215

    
1216
static void do_system_reset(Monitor *mon)
1217
{
1218
    qemu_system_reset_request();
1219
}
1220

    
1221
static void do_system_powerdown(Monitor *mon)
1222
{
1223
    qemu_system_powerdown_request();
1224
}
1225

    
1226
#if defined(TARGET_I386)
1227
static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
1228
{
1229
    monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
1230
                   addr,
1231
                   pte & mask,
1232
                   pte & PG_GLOBAL_MASK ? 'G' : '-',
1233
                   pte & PG_PSE_MASK ? 'P' : '-',
1234
                   pte & PG_DIRTY_MASK ? 'D' : '-',
1235
                   pte & PG_ACCESSED_MASK ? 'A' : '-',
1236
                   pte & PG_PCD_MASK ? 'C' : '-',
1237
                   pte & PG_PWT_MASK ? 'T' : '-',
1238
                   pte & PG_USER_MASK ? 'U' : '-',
1239
                   pte & PG_RW_MASK ? 'W' : '-');
1240
}
1241

    
1242
static void tlb_info(Monitor *mon)
1243
{
1244
    CPUState *env;
1245
    int l1, l2;
1246
    uint32_t pgd, pde, pte;
1247

    
1248
    env = mon_get_cpu();
1249
    if (!env)
1250
        return;
1251

    
1252
    if (!(env->cr[0] & CR0_PG_MASK)) {
1253
        monitor_printf(mon, "PG disabled\n");
1254
        return;
1255
    }
1256
    pgd = env->cr[3] & ~0xfff;
1257
    for(l1 = 0; l1 < 1024; l1++) {
1258
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1259
        pde = le32_to_cpu(pde);
1260
        if (pde & PG_PRESENT_MASK) {
1261
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1262
                print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
1263
            } else {
1264
                for(l2 = 0; l2 < 1024; l2++) {
1265
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1266
                                             (uint8_t *)&pte, 4);
1267
                    pte = le32_to_cpu(pte);
1268
                    if (pte & PG_PRESENT_MASK) {
1269
                        print_pte(mon, (l1 << 22) + (l2 << 12),
1270
                                  pte & ~PG_PSE_MASK,
1271
                                  ~0xfff);
1272
                    }
1273
                }
1274
            }
1275
        }
1276
    }
1277
}
1278

    
1279
static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
1280
                      uint32_t end, int prot)
1281
{
1282
    int prot1;
1283
    prot1 = *plast_prot;
1284
    if (prot != prot1) {
1285
        if (*pstart != -1) {
1286
            monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
1287
                           *pstart, end, end - *pstart,
1288
                           prot1 & PG_USER_MASK ? 'u' : '-',
1289
                           'r',
1290
                           prot1 & PG_RW_MASK ? 'w' : '-');
1291
        }
1292
        if (prot != 0)
1293
            *pstart = end;
1294
        else
1295
            *pstart = -1;
1296
        *plast_prot = prot;
1297
    }
1298
}
1299

    
1300
static void mem_info(Monitor *mon)
1301
{
1302
    CPUState *env;
1303
    int l1, l2, prot, last_prot;
1304
    uint32_t pgd, pde, pte, start, end;
1305

    
1306
    env = mon_get_cpu();
1307
    if (!env)
1308
        return;
1309

    
1310
    if (!(env->cr[0] & CR0_PG_MASK)) {
1311
        monitor_printf(mon, "PG disabled\n");
1312
        return;
1313
    }
1314
    pgd = env->cr[3] & ~0xfff;
1315
    last_prot = 0;
1316
    start = -1;
1317
    for(l1 = 0; l1 < 1024; l1++) {
1318
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1319
        pde = le32_to_cpu(pde);
1320
        end = l1 << 22;
1321
        if (pde & PG_PRESENT_MASK) {
1322
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1323
                prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1324
                mem_print(mon, &start, &last_prot, end, prot);
1325
            } else {
1326
                for(l2 = 0; l2 < 1024; l2++) {
1327
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1328
                                             (uint8_t *)&pte, 4);
1329
                    pte = le32_to_cpu(pte);
1330
                    end = (l1 << 22) + (l2 << 12);
1331
                    if (pte & PG_PRESENT_MASK) {
1332
                        prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1333
                    } else {
1334
                        prot = 0;
1335
                    }
1336
                    mem_print(mon, &start, &last_prot, end, prot);
1337
                }
1338
            }
1339
        } else {
1340
            prot = 0;
1341
            mem_print(mon, &start, &last_prot, end, prot);
1342
        }
1343
    }
1344
}
1345
#endif
1346

    
1347
#if defined(TARGET_SH4)
1348

    
1349
static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
1350
{
1351
    monitor_printf(mon, " tlb%i:\t"
1352
                   "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1353
                   "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1354
                   "dirty=%hhu writethrough=%hhu\n",
1355
                   idx,
1356
                   tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1357
                   tlb->v, tlb->sh, tlb->c, tlb->pr,
1358
                   tlb->d, tlb->wt);
1359
}
1360

    
1361
static void tlb_info(Monitor *mon)
1362
{
1363
    CPUState *env = mon_get_cpu();
1364
    int i;
1365

    
1366
    monitor_printf (mon, "ITLB:\n");
1367
    for (i = 0 ; i < ITLB_SIZE ; i++)
1368
        print_tlb (mon, i, &env->itlb[i]);
1369
    monitor_printf (mon, "UTLB:\n");
1370
    for (i = 0 ; i < UTLB_SIZE ; i++)
1371
        print_tlb (mon, i, &env->utlb[i]);
1372
}
1373

    
1374
#endif
1375

    
1376
static void do_info_kqemu(Monitor *mon)
1377
{
1378
#ifdef CONFIG_KQEMU
1379
    CPUState *env;
1380
    int val;
1381
    val = 0;
1382
    env = mon_get_cpu();
1383
    if (!env) {
1384
        monitor_printf(mon, "No cpu initialized yet");
1385
        return;
1386
    }
1387
    val = env->kqemu_enabled;
1388
    monitor_printf(mon, "kqemu support: ");
1389
    switch(val) {
1390
    default:
1391
    case 0:
1392
        monitor_printf(mon, "disabled\n");
1393
        break;
1394
    case 1:
1395
        monitor_printf(mon, "enabled for user code\n");
1396
        break;
1397
    case 2:
1398
        monitor_printf(mon, "enabled for user and kernel code\n");
1399
        break;
1400
    }
1401
#else
1402
    monitor_printf(mon, "kqemu support: not compiled\n");
1403
#endif
1404
}
1405

    
1406
static void do_info_kvm(Monitor *mon)
1407
{
1408
#ifdef CONFIG_KVM
1409
    monitor_printf(mon, "kvm support: ");
1410
    if (kvm_enabled())
1411
        monitor_printf(mon, "enabled\n");
1412
    else
1413
        monitor_printf(mon, "disabled\n");
1414
#else
1415
    monitor_printf(mon, "kvm support: not compiled\n");
1416
#endif
1417
}
1418

    
1419
static void do_info_numa(Monitor *mon)
1420
{
1421
    int i;
1422
    CPUState *env;
1423

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

    
1438
#ifdef CONFIG_PROFILER
1439

    
1440
int64_t kqemu_time;
1441
int64_t qemu_time;
1442
int64_t kqemu_exec_count;
1443
int64_t dev_time;
1444
int64_t kqemu_ret_int_count;
1445
int64_t kqemu_ret_excp_count;
1446
int64_t kqemu_ret_intr_count;
1447

    
1448
static void do_info_profile(Monitor *mon)
1449
{
1450
    int64_t total;
1451
    total = qemu_time;
1452
    if (total == 0)
1453
        total = 1;
1454
    monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
1455
                   dev_time, dev_time / (double)ticks_per_sec);
1456
    monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
1457
                   qemu_time, qemu_time / (double)ticks_per_sec);
1458
    monitor_printf(mon, "kqemu time  %" PRId64 " (%0.3f %0.1f%%) count=%"
1459
                        PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%"
1460
                        PRId64 "\n",
1461
                   kqemu_time, kqemu_time / (double)ticks_per_sec,
1462
                   kqemu_time / (double)total * 100.0,
1463
                   kqemu_exec_count,
1464
                   kqemu_ret_int_count,
1465
                   kqemu_ret_excp_count,
1466
                   kqemu_ret_intr_count);
1467
    qemu_time = 0;
1468
    kqemu_time = 0;
1469
    kqemu_exec_count = 0;
1470
    dev_time = 0;
1471
    kqemu_ret_int_count = 0;
1472
    kqemu_ret_excp_count = 0;
1473
    kqemu_ret_intr_count = 0;
1474
#ifdef CONFIG_KQEMU
1475
    kqemu_record_dump();
1476
#endif
1477
}
1478
#else
1479
static void do_info_profile(Monitor *mon)
1480
{
1481
    monitor_printf(mon, "Internal profiler not compiled\n");
1482
}
1483
#endif
1484

    
1485
/* Capture support */
1486
static LIST_HEAD (capture_list_head, CaptureState) capture_head;
1487

    
1488
static void do_info_capture(Monitor *mon)
1489
{
1490
    int i;
1491
    CaptureState *s;
1492

    
1493
    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1494
        monitor_printf(mon, "[%d]: ", i);
1495
        s->ops.info (s->opaque);
1496
    }
1497
}
1498

    
1499
#ifdef HAS_AUDIO
1500
static void do_stop_capture(Monitor *mon, int n)
1501
{
1502
    int i;
1503
    CaptureState *s;
1504

    
1505
    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1506
        if (i == n) {
1507
            s->ops.destroy (s->opaque);
1508
            LIST_REMOVE (s, entries);
1509
            qemu_free (s);
1510
            return;
1511
        }
1512
    }
1513
}
1514

    
1515
static void do_wav_capture(Monitor *mon, const char *path,
1516
                           int has_freq, int freq,
1517
                           int has_bits, int bits,
1518
                           int has_channels, int nchannels)
1519
{
1520
    CaptureState *s;
1521

    
1522
    s = qemu_mallocz (sizeof (*s));
1523

    
1524
    freq = has_freq ? freq : 44100;
1525
    bits = has_bits ? bits : 16;
1526
    nchannels = has_channels ? nchannels : 2;
1527

    
1528
    if (wav_start_capture (s, path, freq, bits, nchannels)) {
1529
        monitor_printf(mon, "Faied to add wave capture\n");
1530
        qemu_free (s);
1531
    }
1532
    LIST_INSERT_HEAD (&capture_head, s, entries);
1533
}
1534
#endif
1535

    
1536
#if defined(TARGET_I386)
1537
static void do_inject_nmi(Monitor *mon, int cpu_index)
1538
{
1539
    CPUState *env;
1540

    
1541
    for (env = first_cpu; env != NULL; env = env->next_cpu)
1542
        if (env->cpu_index == cpu_index) {
1543
            cpu_interrupt(env, CPU_INTERRUPT_NMI);
1544
            break;
1545
        }
1546
}
1547
#endif
1548

    
1549
static void do_info_status(Monitor *mon)
1550
{
1551
    if (vm_running) {
1552
        if (singlestep) {
1553
            monitor_printf(mon, "VM status: running (single step mode)\n");
1554
        } else {
1555
            monitor_printf(mon, "VM status: running\n");
1556
        }
1557
    } else
1558
       monitor_printf(mon, "VM status: paused\n");
1559
}
1560

    
1561

    
1562
static void do_balloon(Monitor *mon, int value)
1563
{
1564
    ram_addr_t target = value;
1565
    qemu_balloon(target << 20);
1566
}
1567

    
1568
static void do_info_balloon(Monitor *mon)
1569
{
1570
    ram_addr_t actual;
1571

    
1572
    actual = qemu_balloon_status();
1573
    if (kvm_enabled() && !kvm_has_sync_mmu())
1574
        monitor_printf(mon, "Using KVM without synchronous MMU, "
1575
                       "ballooning disabled\n");
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 void do_acl(Monitor *mon,
1583
                   const char *command,
1584
                   const char *aclname,
1585
                   const char *match,
1586
                   int has_index,
1587
                   int index)
1588
{
1589
    qemu_acl *acl;
1590

    
1591
    acl = qemu_acl_find(aclname);
1592
    if (!acl) {
1593
        monitor_printf(mon, "acl: unknown list '%s'\n", aclname);
1594
        return;
1595
    }
1596

    
1597
    if (strcmp(command, "show") == 0) {
1598
        int i = 0;
1599
        qemu_acl_entry *entry;
1600
        monitor_printf(mon, "policy: %s\n",
1601
                       acl->defaultDeny ? "deny" : "allow");
1602
        TAILQ_FOREACH(entry, &acl->entries, next) {
1603
            i++;
1604
            monitor_printf(mon, "%d: %s %s\n", i,
1605
                           entry->deny ? "deny" : "allow",
1606
                           entry->match);
1607
        }
1608
    } else if (strcmp(command, "reset") == 0) {
1609
        qemu_acl_reset(acl);
1610
        monitor_printf(mon, "acl: removed all rules\n");
1611
    } else if (strcmp(command, "policy") == 0) {
1612
        if (!match) {
1613
            monitor_printf(mon, "acl: missing policy parameter\n");
1614
            return;
1615
        }
1616

    
1617
        if (strcmp(match, "allow") == 0) {
1618
            acl->defaultDeny = 0;
1619
            monitor_printf(mon, "acl: policy set to 'allow'\n");
1620
        } else if (strcmp(match, "deny") == 0) {
1621
            acl->defaultDeny = 1;
1622
            monitor_printf(mon, "acl: policy set to 'deny'\n");
1623
        } else {
1624
            monitor_printf(mon, "acl: unknown policy '%s', expected 'deny' or 'allow'\n", match);
1625
        }
1626
    } else if ((strcmp(command, "allow") == 0) ||
1627
               (strcmp(command, "deny") == 0)) {
1628
        int deny = strcmp(command, "deny") == 0 ? 1 : 0;
1629
        int ret;
1630

    
1631
        if (!match) {
1632
            monitor_printf(mon, "acl: missing match parameter\n");
1633
            return;
1634
        }
1635

    
1636
        if (has_index)
1637
            ret = qemu_acl_insert(acl, deny, match, index);
1638
        else
1639
            ret = qemu_acl_append(acl, deny, match);
1640
        if (ret < 0)
1641
            monitor_printf(mon, "acl: unable to add acl entry\n");
1642
        else
1643
            monitor_printf(mon, "acl: added rule at position %d\n", ret);
1644
    } else if (strcmp(command, "remove") == 0) {
1645
        int ret;
1646

    
1647
        if (!match) {
1648
            monitor_printf(mon, "acl: missing match parameter\n");
1649
            return;
1650
        }
1651

    
1652
        ret = qemu_acl_remove(acl, match);
1653
        if (ret < 0)
1654
            monitor_printf(mon, "acl: no matching acl entry\n");
1655
        else
1656
            monitor_printf(mon, "acl: removed rule at position %d\n", ret);
1657
    } else {
1658
        monitor_printf(mon, "acl: unknown command '%s'\n", command);
1659
    }
1660
}
1661

    
1662
static const mon_cmd_t mon_cmds[] = {
1663
#include "qemu-monitor.h"
1664
    { NULL, NULL, },
1665
};
1666

    
1667
/* Please update qemu-monitor.hx when adding or changing commands */
1668
static const mon_cmd_t info_cmds[] = {
1669
    { "version", "", do_info_version,
1670
      "", "show the version of QEMU" },
1671
    { "network", "", do_info_network,
1672
      "", "show the network state" },
1673
    { "chardev", "", qemu_chr_info,
1674
      "", "show the character devices" },
1675
    { "block", "", bdrv_info,
1676
      "", "show the block devices" },
1677
    { "blockstats", "", bdrv_info_stats,
1678
      "", "show block device statistics" },
1679
    { "registers", "", do_info_registers,
1680
      "", "show the cpu registers" },
1681
    { "cpus", "", do_info_cpus,
1682
      "", "show infos for each CPU" },
1683
    { "history", "", do_info_history,
1684
      "", "show the command line history", },
1685
    { "irq", "", irq_info,
1686
      "", "show the interrupts statistics (if available)", },
1687
    { "pic", "", pic_info,
1688
      "", "show i8259 (PIC) state", },
1689
    { "pci", "", pci_info,
1690
      "", "show PCI info", },
1691
#if defined(TARGET_I386) || defined(TARGET_SH4)
1692
    { "tlb", "", tlb_info,
1693
      "", "show virtual to physical memory mappings", },
1694
#endif
1695
#if defined(TARGET_I386)
1696
    { "mem", "", mem_info,
1697
      "", "show the active virtual memory mappings", },
1698
    { "hpet", "", do_info_hpet,
1699
      "", "show state of HPET", },
1700
#endif
1701
    { "jit", "", do_info_jit,
1702
      "", "show dynamic compiler info", },
1703
    { "kqemu", "", do_info_kqemu,
1704
      "", "show KQEMU information", },
1705
    { "kvm", "", do_info_kvm,
1706
      "", "show KVM information", },
1707
    { "numa", "", do_info_numa,
1708
      "", "show NUMA information", },
1709
    { "usb", "", usb_info,
1710
      "", "show guest USB devices", },
1711
    { "usbhost", "", usb_host_info,
1712
      "", "show host USB devices", },
1713
    { "profile", "", do_info_profile,
1714
      "", "show profiling information", },
1715
    { "capture", "", do_info_capture,
1716
      "", "show capture information" },
1717
    { "snapshots", "", do_info_snapshots,
1718
      "", "show the currently saved VM snapshots" },
1719
    { "status", "", do_info_status,
1720
      "", "show the current VM status (running|paused)" },
1721
    { "pcmcia", "", pcmcia_info,
1722
      "", "show guest PCMCIA status" },
1723
    { "mice", "", do_info_mice,
1724
      "", "show which guest mouse is receiving events" },
1725
    { "vnc", "", do_info_vnc,
1726
      "", "show the vnc server status"},
1727
    { "name", "", do_info_name,
1728
      "", "show the current VM name" },
1729
    { "uuid", "", do_info_uuid,
1730
      "", "show the current VM UUID" },
1731
#if defined(TARGET_PPC)
1732
    { "cpustats", "", do_info_cpu_stats,
1733
      "", "show CPU statistics", },
1734
#endif
1735
#if defined(CONFIG_SLIRP)
1736
    { "slirp", "", do_info_slirp,
1737
      "", "show SLIRP statistics", },
1738
#endif
1739
    { "migrate", "", do_info_migrate, "", "show migration status" },
1740
    { "balloon", "", do_info_balloon,
1741
      "", "show balloon information" },
1742
    { "qtree", "", do_info_qtree,
1743
      "", "show device tree" },
1744
    { NULL, NULL, },
1745
};
1746

    
1747
/*******************************************************************/
1748

    
1749
static const char *pch;
1750
static jmp_buf expr_env;
1751

    
1752
#define MD_TLONG 0
1753
#define MD_I32   1
1754

    
1755
typedef struct MonitorDef {
1756
    const char *name;
1757
    int offset;
1758
    target_long (*get_value)(const struct MonitorDef *md, int val);
1759
    int type;
1760
} MonitorDef;
1761

    
1762
#if defined(TARGET_I386)
1763
static target_long monitor_get_pc (const struct MonitorDef *md, int val)
1764
{
1765
    CPUState *env = mon_get_cpu();
1766
    if (!env)
1767
        return 0;
1768
    return env->eip + env->segs[R_CS].base;
1769
}
1770
#endif
1771

    
1772
#if defined(TARGET_PPC)
1773
static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
1774
{
1775
    CPUState *env = mon_get_cpu();
1776
    unsigned int u;
1777
    int i;
1778

    
1779
    if (!env)
1780
        return 0;
1781

    
1782
    u = 0;
1783
    for (i = 0; i < 8; i++)
1784
        u |= env->crf[i] << (32 - (4 * i));
1785

    
1786
    return u;
1787
}
1788

    
1789
static target_long monitor_get_msr (const struct MonitorDef *md, int val)
1790
{
1791
    CPUState *env = mon_get_cpu();
1792
    if (!env)
1793
        return 0;
1794
    return env->msr;
1795
}
1796

    
1797
static target_long monitor_get_xer (const struct MonitorDef *md, int val)
1798
{
1799
    CPUState *env = mon_get_cpu();
1800
    if (!env)
1801
        return 0;
1802
    return env->xer;
1803
}
1804

    
1805
static target_long monitor_get_decr (const struct MonitorDef *md, int val)
1806
{
1807
    CPUState *env = mon_get_cpu();
1808
    if (!env)
1809
        return 0;
1810
    return cpu_ppc_load_decr(env);
1811
}
1812

    
1813
static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
1814
{
1815
    CPUState *env = mon_get_cpu();
1816
    if (!env)
1817
        return 0;
1818
    return cpu_ppc_load_tbu(env);
1819
}
1820

    
1821
static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
1822
{
1823
    CPUState *env = mon_get_cpu();
1824
    if (!env)
1825
        return 0;
1826
    return cpu_ppc_load_tbl(env);
1827
}
1828
#endif
1829

    
1830
#if defined(TARGET_SPARC)
1831
#ifndef TARGET_SPARC64
1832
static target_long monitor_get_psr (const struct MonitorDef *md, int val)
1833
{
1834
    CPUState *env = mon_get_cpu();
1835
    if (!env)
1836
        return 0;
1837
    return GET_PSR(env);
1838
}
1839
#endif
1840

    
1841
static target_long monitor_get_reg(const struct MonitorDef *md, int val)
1842
{
1843
    CPUState *env = mon_get_cpu();
1844
    if (!env)
1845
        return 0;
1846
    return env->regwptr[val];
1847
}
1848
#endif
1849

    
1850
static const MonitorDef monitor_defs[] = {
1851
#ifdef TARGET_I386
1852

    
1853
#define SEG(name, seg) \
1854
    { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
1855
    { name ".base", offsetof(CPUState, segs[seg].base) },\
1856
    { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
1857

    
1858
    { "eax", offsetof(CPUState, regs[0]) },
1859
    { "ecx", offsetof(CPUState, regs[1]) },
1860
    { "edx", offsetof(CPUState, regs[2]) },
1861
    { "ebx", offsetof(CPUState, regs[3]) },
1862
    { "esp|sp", offsetof(CPUState, regs[4]) },
1863
    { "ebp|fp", offsetof(CPUState, regs[5]) },
1864
    { "esi", offsetof(CPUState, regs[6]) },
1865
    { "edi", offsetof(CPUState, regs[7]) },
1866
#ifdef TARGET_X86_64
1867
    { "r8", offsetof(CPUState, regs[8]) },
1868
    { "r9", offsetof(CPUState, regs[9]) },
1869
    { "r10", offsetof(CPUState, regs[10]) },
1870
    { "r11", offsetof(CPUState, regs[11]) },
1871
    { "r12", offsetof(CPUState, regs[12]) },
1872
    { "r13", offsetof(CPUState, regs[13]) },
1873
    { "r14", offsetof(CPUState, regs[14]) },
1874
    { "r15", offsetof(CPUState, regs[15]) },
1875
#endif
1876
    { "eflags", offsetof(CPUState, eflags) },
1877
    { "eip", offsetof(CPUState, eip) },
1878
    SEG("cs", R_CS)
1879
    SEG("ds", R_DS)
1880
    SEG("es", R_ES)
1881
    SEG("ss", R_SS)
1882
    SEG("fs", R_FS)
1883
    SEG("gs", R_GS)
1884
    { "pc", 0, monitor_get_pc, },
1885
#elif defined(TARGET_PPC)
1886
    /* General purpose registers */
1887
    { "r0", offsetof(CPUState, gpr[0]) },
1888
    { "r1", offsetof(CPUState, gpr[1]) },
1889
    { "r2", offsetof(CPUState, gpr[2]) },
1890
    { "r3", offsetof(CPUState, gpr[3]) },
1891
    { "r4", offsetof(CPUState, gpr[4]) },
1892
    { "r5", offsetof(CPUState, gpr[5]) },
1893
    { "r6", offsetof(CPUState, gpr[6]) },
1894
    { "r7", offsetof(CPUState, gpr[7]) },
1895
    { "r8", offsetof(CPUState, gpr[8]) },
1896
    { "r9", offsetof(CPUState, gpr[9]) },
1897
    { "r10", offsetof(CPUState, gpr[10]) },
1898
    { "r11", offsetof(CPUState, gpr[11]) },
1899
    { "r12", offsetof(CPUState, gpr[12]) },
1900
    { "r13", offsetof(CPUState, gpr[13]) },
1901
    { "r14", offsetof(CPUState, gpr[14]) },
1902
    { "r15", offsetof(CPUState, gpr[15]) },
1903
    { "r16", offsetof(CPUState, gpr[16]) },
1904
    { "r17", offsetof(CPUState, gpr[17]) },
1905
    { "r18", offsetof(CPUState, gpr[18]) },
1906
    { "r19", offsetof(CPUState, gpr[19]) },
1907
    { "r20", offsetof(CPUState, gpr[20]) },
1908
    { "r21", offsetof(CPUState, gpr[21]) },
1909
    { "r22", offsetof(CPUState, gpr[22]) },
1910
    { "r23", offsetof(CPUState, gpr[23]) },
1911
    { "r24", offsetof(CPUState, gpr[24]) },
1912
    { "r25", offsetof(CPUState, gpr[25]) },
1913
    { "r26", offsetof(CPUState, gpr[26]) },
1914
    { "r27", offsetof(CPUState, gpr[27]) },
1915
    { "r28", offsetof(CPUState, gpr[28]) },
1916
    { "r29", offsetof(CPUState, gpr[29]) },
1917
    { "r30", offsetof(CPUState, gpr[30]) },
1918
    { "r31", offsetof(CPUState, gpr[31]) },
1919
    /* Floating point registers */
1920
    { "f0", offsetof(CPUState, fpr[0]) },
1921
    { "f1", offsetof(CPUState, fpr[1]) },
1922
    { "f2", offsetof(CPUState, fpr[2]) },
1923
    { "f3", offsetof(CPUState, fpr[3]) },
1924
    { "f4", offsetof(CPUState, fpr[4]) },
1925
    { "f5", offsetof(CPUState, fpr[5]) },
1926
    { "f6", offsetof(CPUState, fpr[6]) },
1927
    { "f7", offsetof(CPUState, fpr[7]) },
1928
    { "f8", offsetof(CPUState, fpr[8]) },
1929
    { "f9", offsetof(CPUState, fpr[9]) },
1930
    { "f10", offsetof(CPUState, fpr[10]) },
1931
    { "f11", offsetof(CPUState, fpr[11]) },
1932
    { "f12", offsetof(CPUState, fpr[12]) },
1933
    { "f13", offsetof(CPUState, fpr[13]) },
1934
    { "f14", offsetof(CPUState, fpr[14]) },
1935
    { "f15", offsetof(CPUState, fpr[15]) },
1936
    { "f16", offsetof(CPUState, fpr[16]) },
1937
    { "f17", offsetof(CPUState, fpr[17]) },
1938
    { "f18", offsetof(CPUState, fpr[18]) },
1939
    { "f19", offsetof(CPUState, fpr[19]) },
1940
    { "f20", offsetof(CPUState, fpr[20]) },
1941
    { "f21", offsetof(CPUState, fpr[21]) },
1942
    { "f22", offsetof(CPUState, fpr[22]) },
1943
    { "f23", offsetof(CPUState, fpr[23]) },
1944
    { "f24", offsetof(CPUState, fpr[24]) },
1945
    { "f25", offsetof(CPUState, fpr[25]) },
1946
    { "f26", offsetof(CPUState, fpr[26]) },
1947
    { "f27", offsetof(CPUState, fpr[27]) },
1948
    { "f28", offsetof(CPUState, fpr[28]) },
1949
    { "f29", offsetof(CPUState, fpr[29]) },
1950
    { "f30", offsetof(CPUState, fpr[30]) },
1951
    { "f31", offsetof(CPUState, fpr[31]) },
1952
    { "fpscr", offsetof(CPUState, fpscr) },
1953
    /* Next instruction pointer */
1954
    { "nip|pc", offsetof(CPUState, nip) },
1955
    { "lr", offsetof(CPUState, lr) },
1956
    { "ctr", offsetof(CPUState, ctr) },
1957
    { "decr", 0, &monitor_get_decr, },
1958
    { "ccr", 0, &monitor_get_ccr, },
1959
    /* Machine state register */
1960
    { "msr", 0, &monitor_get_msr, },
1961
    { "xer", 0, &monitor_get_xer, },
1962
    { "tbu", 0, &monitor_get_tbu, },
1963
    { "tbl", 0, &monitor_get_tbl, },
1964
#if defined(TARGET_PPC64)
1965
    /* Address space register */
1966
    { "asr", offsetof(CPUState, asr) },
1967
#endif
1968
    /* Segment registers */
1969
    { "sdr1", offsetof(CPUState, sdr1) },
1970
    { "sr0", offsetof(CPUState, sr[0]) },
1971
    { "sr1", offsetof(CPUState, sr[1]) },
1972
    { "sr2", offsetof(CPUState, sr[2]) },
1973
    { "sr3", offsetof(CPUState, sr[3]) },
1974
    { "sr4", offsetof(CPUState, sr[4]) },
1975
    { "sr5", offsetof(CPUState, sr[5]) },
1976
    { "sr6", offsetof(CPUState, sr[6]) },
1977
    { "sr7", offsetof(CPUState, sr[7]) },
1978
    { "sr8", offsetof(CPUState, sr[8]) },
1979
    { "sr9", offsetof(CPUState, sr[9]) },
1980
    { "sr10", offsetof(CPUState, sr[10]) },
1981
    { "sr11", offsetof(CPUState, sr[11]) },
1982
    { "sr12", offsetof(CPUState, sr[12]) },
1983
    { "sr13", offsetof(CPUState, sr[13]) },
1984
    { "sr14", offsetof(CPUState, sr[14]) },
1985
    { "sr15", offsetof(CPUState, sr[15]) },
1986
    /* Too lazy to put BATs and SPRs ... */
1987
#elif defined(TARGET_SPARC)
1988
    { "g0", offsetof(CPUState, gregs[0]) },
1989
    { "g1", offsetof(CPUState, gregs[1]) },
1990
    { "g2", offsetof(CPUState, gregs[2]) },
1991
    { "g3", offsetof(CPUState, gregs[3]) },
1992
    { "g4", offsetof(CPUState, gregs[4]) },
1993
    { "g5", offsetof(CPUState, gregs[5]) },
1994
    { "g6", offsetof(CPUState, gregs[6]) },
1995
    { "g7", offsetof(CPUState, gregs[7]) },
1996
    { "o0", 0, monitor_get_reg },
1997
    { "o1", 1, monitor_get_reg },
1998
    { "o2", 2, monitor_get_reg },
1999
    { "o3", 3, monitor_get_reg },
2000
    { "o4", 4, monitor_get_reg },
2001
    { "o5", 5, monitor_get_reg },
2002
    { "o6", 6, monitor_get_reg },
2003
    { "o7", 7, monitor_get_reg },
2004
    { "l0", 8, monitor_get_reg },
2005
    { "l1", 9, monitor_get_reg },
2006
    { "l2", 10, monitor_get_reg },
2007
    { "l3", 11, monitor_get_reg },
2008
    { "l4", 12, monitor_get_reg },
2009
    { "l5", 13, monitor_get_reg },
2010
    { "l6", 14, monitor_get_reg },
2011
    { "l7", 15, monitor_get_reg },
2012
    { "i0", 16, monitor_get_reg },
2013
    { "i1", 17, monitor_get_reg },
2014
    { "i2", 18, monitor_get_reg },
2015
    { "i3", 19, monitor_get_reg },
2016
    { "i4", 20, monitor_get_reg },
2017
    { "i5", 21, monitor_get_reg },
2018
    { "i6", 22, monitor_get_reg },
2019
    { "i7", 23, monitor_get_reg },
2020
    { "pc", offsetof(CPUState, pc) },
2021
    { "npc", offsetof(CPUState, npc) },
2022
    { "y", offsetof(CPUState, y) },
2023
#ifndef TARGET_SPARC64
2024
    { "psr", 0, &monitor_get_psr, },
2025
    { "wim", offsetof(CPUState, wim) },
2026
#endif
2027
    { "tbr", offsetof(CPUState, tbr) },
2028
    { "fsr", offsetof(CPUState, fsr) },
2029
    { "f0", offsetof(CPUState, fpr[0]) },
2030
    { "f1", offsetof(CPUState, fpr[1]) },
2031
    { "f2", offsetof(CPUState, fpr[2]) },
2032
    { "f3", offsetof(CPUState, fpr[3]) },
2033
    { "f4", offsetof(CPUState, fpr[4]) },
2034
    { "f5", offsetof(CPUState, fpr[5]) },
2035
    { "f6", offsetof(CPUState, fpr[6]) },
2036
    { "f7", offsetof(CPUState, fpr[7]) },
2037
    { "f8", offsetof(CPUState, fpr[8]) },
2038
    { "f9", offsetof(CPUState, fpr[9]) },
2039
    { "f10", offsetof(CPUState, fpr[10]) },
2040
    { "f11", offsetof(CPUState, fpr[11]) },
2041
    { "f12", offsetof(CPUState, fpr[12]) },
2042
    { "f13", offsetof(CPUState, fpr[13]) },
2043
    { "f14", offsetof(CPUState, fpr[14]) },
2044
    { "f15", offsetof(CPUState, fpr[15]) },
2045
    { "f16", offsetof(CPUState, fpr[16]) },
2046
    { "f17", offsetof(CPUState, fpr[17]) },
2047
    { "f18", offsetof(CPUState, fpr[18]) },
2048
    { "f19", offsetof(CPUState, fpr[19]) },
2049
    { "f20", offsetof(CPUState, fpr[20]) },
2050
    { "f21", offsetof(CPUState, fpr[21]) },
2051
    { "f22", offsetof(CPUState, fpr[22]) },
2052
    { "f23", offsetof(CPUState, fpr[23]) },
2053
    { "f24", offsetof(CPUState, fpr[24]) },
2054
    { "f25", offsetof(CPUState, fpr[25]) },
2055
    { "f26", offsetof(CPUState, fpr[26]) },
2056
    { "f27", offsetof(CPUState, fpr[27]) },
2057
    { "f28", offsetof(CPUState, fpr[28]) },
2058
    { "f29", offsetof(CPUState, fpr[29]) },
2059
    { "f30", offsetof(CPUState, fpr[30]) },
2060
    { "f31", offsetof(CPUState, fpr[31]) },
2061
#ifdef TARGET_SPARC64
2062
    { "f32", offsetof(CPUState, fpr[32]) },
2063
    { "f34", offsetof(CPUState, fpr[34]) },
2064
    { "f36", offsetof(CPUState, fpr[36]) },
2065
    { "f38", offsetof(CPUState, fpr[38]) },
2066
    { "f40", offsetof(CPUState, fpr[40]) },
2067
    { "f42", offsetof(CPUState, fpr[42]) },
2068
    { "f44", offsetof(CPUState, fpr[44]) },
2069
    { "f46", offsetof(CPUState, fpr[46]) },
2070
    { "f48", offsetof(CPUState, fpr[48]) },
2071
    { "f50", offsetof(CPUState, fpr[50]) },
2072
    { "f52", offsetof(CPUState, fpr[52]) },
2073
    { "f54", offsetof(CPUState, fpr[54]) },
2074
    { "f56", offsetof(CPUState, fpr[56]) },
2075
    { "f58", offsetof(CPUState, fpr[58]) },
2076
    { "f60", offsetof(CPUState, fpr[60]) },
2077
    { "f62", offsetof(CPUState, fpr[62]) },
2078
    { "asi", offsetof(CPUState, asi) },
2079
    { "pstate", offsetof(CPUState, pstate) },
2080
    { "cansave", offsetof(CPUState, cansave) },
2081
    { "canrestore", offsetof(CPUState, canrestore) },
2082
    { "otherwin", offsetof(CPUState, otherwin) },
2083
    { "wstate", offsetof(CPUState, wstate) },
2084
    { "cleanwin", offsetof(CPUState, cleanwin) },
2085
    { "fprs", offsetof(CPUState, fprs) },
2086
#endif
2087
#endif
2088
    { NULL },
2089
};
2090

    
2091
static void expr_error(Monitor *mon, const char *msg)
2092
{
2093
    monitor_printf(mon, "%s\n", msg);
2094
    longjmp(expr_env, 1);
2095
}
2096

    
2097
/* return 0 if OK, -1 if not found, -2 if no CPU defined */
2098
static int get_monitor_def(target_long *pval, const char *name)
2099
{
2100
    const MonitorDef *md;
2101
    void *ptr;
2102

    
2103
    for(md = monitor_defs; md->name != NULL; md++) {
2104
        if (compare_cmd(name, md->name)) {
2105
            if (md->get_value) {
2106
                *pval = md->get_value(md, md->offset);
2107
            } else {
2108
                CPUState *env = mon_get_cpu();
2109
                if (!env)
2110
                    return -2;
2111
                ptr = (uint8_t *)env + md->offset;
2112
                switch(md->type) {
2113
                case MD_I32:
2114
                    *pval = *(int32_t *)ptr;
2115
                    break;
2116
                case MD_TLONG:
2117
                    *pval = *(target_long *)ptr;
2118
                    break;
2119
                default:
2120
                    *pval = 0;
2121
                    break;
2122
                }
2123
            }
2124
            return 0;
2125
        }
2126
    }
2127
    return -1;
2128
}
2129

    
2130
static void next(void)
2131
{
2132
    if (pch != '\0') {
2133
        pch++;
2134
        while (qemu_isspace(*pch))
2135
            pch++;
2136
    }
2137
}
2138

    
2139
static int64_t expr_sum(Monitor *mon);
2140

    
2141
static int64_t expr_unary(Monitor *mon)
2142
{
2143
    int64_t n;
2144
    char *p;
2145
    int ret;
2146

    
2147
    switch(*pch) {
2148
    case '+':
2149
        next();
2150
        n = expr_unary(mon);
2151
        break;
2152
    case '-':
2153
        next();
2154
        n = -expr_unary(mon);
2155
        break;
2156
    case '~':
2157
        next();
2158
        n = ~expr_unary(mon);
2159
        break;
2160
    case '(':
2161
        next();
2162
        n = expr_sum(mon);
2163
        if (*pch != ')') {
2164
            expr_error(mon, "')' expected");
2165
        }
2166
        next();
2167
        break;
2168
    case '\'':
2169
        pch++;
2170
        if (*pch == '\0')
2171
            expr_error(mon, "character constant expected");
2172
        n = *pch;
2173
        pch++;
2174
        if (*pch != '\'')
2175
            expr_error(mon, "missing terminating \' character");
2176
        next();
2177
        break;
2178
    case '$':
2179
        {
2180
            char buf[128], *q;
2181
            target_long reg=0;
2182

    
2183
            pch++;
2184
            q = buf;
2185
            while ((*pch >= 'a' && *pch <= 'z') ||
2186
                   (*pch >= 'A' && *pch <= 'Z') ||
2187
                   (*pch >= '0' && *pch <= '9') ||
2188
                   *pch == '_' || *pch == '.') {
2189
                if ((q - buf) < sizeof(buf) - 1)
2190
                    *q++ = *pch;
2191
                pch++;
2192
            }
2193
            while (qemu_isspace(*pch))
2194
                pch++;
2195
            *q = 0;
2196
            ret = get_monitor_def(&reg, buf);
2197
            if (ret == -1)
2198
                expr_error(mon, "unknown register");
2199
            else if (ret == -2)
2200
                expr_error(mon, "no cpu defined");
2201
            n = reg;
2202
        }
2203
        break;
2204
    case '\0':
2205
        expr_error(mon, "unexpected end of expression");
2206
        n = 0;
2207
        break;
2208
    default:
2209
#if TARGET_PHYS_ADDR_BITS > 32
2210
        n = strtoull(pch, &p, 0);
2211
#else
2212
        n = strtoul(pch, &p, 0);
2213
#endif
2214
        if (pch == p) {
2215
            expr_error(mon, "invalid char in expression");
2216
        }
2217
        pch = p;
2218
        while (qemu_isspace(*pch))
2219
            pch++;
2220
        break;
2221
    }
2222
    return n;
2223
}
2224

    
2225

    
2226
static int64_t expr_prod(Monitor *mon)
2227
{
2228
    int64_t val, val2;
2229
    int op;
2230

    
2231
    val = expr_unary(mon);
2232
    for(;;) {
2233
        op = *pch;
2234
        if (op != '*' && op != '/' && op != '%')
2235
            break;
2236
        next();
2237
        val2 = expr_unary(mon);
2238
        switch(op) {
2239
        default:
2240
        case '*':
2241
            val *= val2;
2242
            break;
2243
        case '/':
2244
        case '%':
2245
            if (val2 == 0)
2246
                expr_error(mon, "division by zero");
2247
            if (op == '/')
2248
                val /= val2;
2249
            else
2250
                val %= val2;
2251
            break;
2252
        }
2253
    }
2254
    return val;
2255
}
2256

    
2257
static int64_t expr_logic(Monitor *mon)
2258
{
2259
    int64_t val, val2;
2260
    int op;
2261

    
2262
    val = expr_prod(mon);
2263
    for(;;) {
2264
        op = *pch;
2265
        if (op != '&' && op != '|' && op != '^')
2266
            break;
2267
        next();
2268
        val2 = expr_prod(mon);
2269
        switch(op) {
2270
        default:
2271
        case '&':
2272
            val &= val2;
2273
            break;
2274
        case '|':
2275
            val |= val2;
2276
            break;
2277
        case '^':
2278
            val ^= val2;
2279
            break;
2280
        }
2281
    }
2282
    return val;
2283
}
2284

    
2285
static int64_t expr_sum(Monitor *mon)
2286
{
2287
    int64_t val, val2;
2288
    int op;
2289

    
2290
    val = expr_logic(mon);
2291
    for(;;) {
2292
        op = *pch;
2293
        if (op != '+' && op != '-')
2294
            break;
2295
        next();
2296
        val2 = expr_logic(mon);
2297
        if (op == '+')
2298
            val += val2;
2299
        else
2300
            val -= val2;
2301
    }
2302
    return val;
2303
}
2304

    
2305
static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2306
{
2307
    pch = *pp;
2308
    if (setjmp(expr_env)) {
2309
        *pp = pch;
2310
        return -1;
2311
    }
2312
    while (qemu_isspace(*pch))
2313
        pch++;
2314
    *pval = expr_sum(mon);
2315
    *pp = pch;
2316
    return 0;
2317
}
2318

    
2319
static int get_str(char *buf, int buf_size, const char **pp)
2320
{
2321
    const char *p;
2322
    char *q;
2323
    int c;
2324

    
2325
    q = buf;
2326
    p = *pp;
2327
    while (qemu_isspace(*p))
2328
        p++;
2329
    if (*p == '\0') {
2330
    fail:
2331
        *q = '\0';
2332
        *pp = p;
2333
        return -1;
2334
    }
2335
    if (*p == '\"') {
2336
        p++;
2337
        while (*p != '\0' && *p != '\"') {
2338
            if (*p == '\\') {
2339
                p++;
2340
                c = *p++;
2341
                switch(c) {
2342
                case 'n':
2343
                    c = '\n';
2344
                    break;
2345
                case 'r':
2346
                    c = '\r';
2347
                    break;
2348
                case '\\':
2349
                case '\'':
2350
                case '\"':
2351
                    break;
2352
                default:
2353
                    qemu_printf("unsupported escape code: '\\%c'\n", c);
2354
                    goto fail;
2355
                }
2356
                if ((q - buf) < buf_size - 1) {
2357
                    *q++ = c;
2358
                }
2359
            } else {
2360
                if ((q - buf) < buf_size - 1) {
2361
                    *q++ = *p;
2362
                }
2363
                p++;
2364
            }
2365
        }
2366
        if (*p != '\"') {
2367
            qemu_printf("unterminated string\n");
2368
            goto fail;
2369
        }
2370
        p++;
2371
    } else {
2372
        while (*p != '\0' && !qemu_isspace(*p)) {
2373
            if ((q - buf) < buf_size - 1) {
2374
                *q++ = *p;
2375
            }
2376
            p++;
2377
        }
2378
    }
2379
    *q = '\0';
2380
    *pp = p;
2381
    return 0;
2382
}
2383

    
2384
static int default_fmt_format = 'x';
2385
static int default_fmt_size = 4;
2386

    
2387
#define MAX_ARGS 16
2388

    
2389
static void monitor_handle_command(Monitor *mon, const char *cmdline)
2390
{
2391
    const char *p, *pstart, *typestr;
2392
    char *q;
2393
    int c, nb_args, len, i, has_arg;
2394
    const mon_cmd_t *cmd;
2395
    char cmdname[256];
2396
    char buf[1024];
2397
    void *str_allocated[MAX_ARGS];
2398
    void *args[MAX_ARGS];
2399
    void (*handler_0)(Monitor *mon);
2400
    void (*handler_1)(Monitor *mon, void *arg0);
2401
    void (*handler_2)(Monitor *mon, void *arg0, void *arg1);
2402
    void (*handler_3)(Monitor *mon, void *arg0, void *arg1, void *arg2);
2403
    void (*handler_4)(Monitor *mon, void *arg0, void *arg1, void *arg2,
2404
                      void *arg3);
2405
    void (*handler_5)(Monitor *mon, void *arg0, void *arg1, void *arg2,
2406
                      void *arg3, void *arg4);
2407
    void (*handler_6)(Monitor *mon, void *arg0, void *arg1, void *arg2,
2408
                      void *arg3, void *arg4, void *arg5);
2409
    void (*handler_7)(Monitor *mon, void *arg0, void *arg1, void *arg2,
2410
                      void *arg3, void *arg4, void *arg5, void *arg6);
2411

    
2412
#ifdef DEBUG
2413
    monitor_printf(mon, "command='%s'\n", cmdline);
2414
#endif
2415

    
2416
    /* extract the command name */
2417
    p = cmdline;
2418
    q = cmdname;
2419
    while (qemu_isspace(*p))
2420
        p++;
2421
    if (*p == '\0')
2422
        return;
2423
    pstart = p;
2424
    while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2425
        p++;
2426
    len = p - pstart;
2427
    if (len > sizeof(cmdname) - 1)
2428
        len = sizeof(cmdname) - 1;
2429
    memcpy(cmdname, pstart, len);
2430
    cmdname[len] = '\0';
2431

    
2432
    /* find the command */
2433
    for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
2434
        if (compare_cmd(cmdname, cmd->name))
2435
            goto found;
2436
    }
2437
    monitor_printf(mon, "unknown command: '%s'\n", cmdname);
2438
    return;
2439
 found:
2440

    
2441
    for(i = 0; i < MAX_ARGS; i++)
2442
        str_allocated[i] = NULL;
2443

    
2444
    /* parse the parameters */
2445
    typestr = cmd->args_type;
2446
    nb_args = 0;
2447
    for(;;) {
2448
        c = *typestr;
2449
        if (c == '\0')
2450
            break;
2451
        typestr++;
2452
        switch(c) {
2453
        case 'F':
2454
        case 'B':
2455
        case 's':
2456
            {
2457
                int ret;
2458
                char *str;
2459

    
2460
                while (qemu_isspace(*p))
2461
                    p++;
2462
                if (*typestr == '?') {
2463
                    typestr++;
2464
                    if (*p == '\0') {
2465
                        /* no optional string: NULL argument */
2466
                        str = NULL;
2467
                        goto add_str;
2468
                    }
2469
                }
2470
                ret = get_str(buf, sizeof(buf), &p);
2471
                if (ret < 0) {
2472
                    switch(c) {
2473
                    case 'F':
2474
                        monitor_printf(mon, "%s: filename expected\n",
2475
                                       cmdname);
2476
                        break;
2477
                    case 'B':
2478
                        monitor_printf(mon, "%s: block device name expected\n",
2479
                                       cmdname);
2480
                        break;
2481
                    default:
2482
                        monitor_printf(mon, "%s: string expected\n", cmdname);
2483
                        break;
2484
                    }
2485
                    goto fail;
2486
                }
2487
                str = qemu_malloc(strlen(buf) + 1);
2488
                pstrcpy(str, sizeof(buf), buf);
2489
                str_allocated[nb_args] = str;
2490
            add_str:
2491
                if (nb_args >= MAX_ARGS) {
2492
                error_args:
2493
                    monitor_printf(mon, "%s: too many arguments\n", cmdname);
2494
                    goto fail;
2495
                }
2496
                args[nb_args++] = str;
2497
            }
2498
            break;
2499
        case '/':
2500
            {
2501
                int count, format, size;
2502

    
2503
                while (qemu_isspace(*p))
2504
                    p++;
2505
                if (*p == '/') {
2506
                    /* format found */
2507
                    p++;
2508
                    count = 1;
2509
                    if (qemu_isdigit(*p)) {
2510
                        count = 0;
2511
                        while (qemu_isdigit(*p)) {
2512
                            count = count * 10 + (*p - '0');
2513
                            p++;
2514
                        }
2515
                    }
2516
                    size = -1;
2517
                    format = -1;
2518
                    for(;;) {
2519
                        switch(*p) {
2520
                        case 'o':
2521
                        case 'd':
2522
                        case 'u':
2523
                        case 'x':
2524
                        case 'i':
2525
                        case 'c':
2526
                            format = *p++;
2527
                            break;
2528
                        case 'b':
2529
                            size = 1;
2530
                            p++;
2531
                            break;
2532
                        case 'h':
2533
                            size = 2;
2534
                            p++;
2535
                            break;
2536
                        case 'w':
2537
                            size = 4;
2538
                            p++;
2539
                            break;
2540
                        case 'g':
2541
                        case 'L':
2542
                            size = 8;
2543
                            p++;
2544
                            break;
2545
                        default:
2546
                            goto next;
2547
                        }
2548
                    }
2549
                next:
2550
                    if (*p != '\0' && !qemu_isspace(*p)) {
2551
                        monitor_printf(mon, "invalid char in format: '%c'\n",
2552
                                       *p);
2553
                        goto fail;
2554
                    }
2555
                    if (format < 0)
2556
                        format = default_fmt_format;
2557
                    if (format != 'i') {
2558
                        /* for 'i', not specifying a size gives -1 as size */
2559
                        if (size < 0)
2560
                            size = default_fmt_size;
2561
                        default_fmt_size = size;
2562
                    }
2563
                    default_fmt_format = format;
2564
                } else {
2565
                    count = 1;
2566
                    format = default_fmt_format;
2567
                    if (format != 'i') {
2568
                        size = default_fmt_size;
2569
                    } else {
2570
                        size = -1;
2571
                    }
2572
                }
2573
                if (nb_args + 3 > MAX_ARGS)
2574
                    goto error_args;
2575
                args[nb_args++] = (void*)(long)count;
2576
                args[nb_args++] = (void*)(long)format;
2577
                args[nb_args++] = (void*)(long)size;
2578
            }
2579
            break;
2580
        case 'i':
2581
        case 'l':
2582
            {
2583
                int64_t val;
2584

    
2585
                while (qemu_isspace(*p))
2586
                    p++;
2587
                if (*typestr == '?' || *typestr == '.') {
2588
                    if (*typestr == '?') {
2589
                        if (*p == '\0')
2590
                            has_arg = 0;
2591
                        else
2592
                            has_arg = 1;
2593
                    } else {
2594
                        if (*p == '.') {
2595
                            p++;
2596
                            while (qemu_isspace(*p))
2597
                                p++;
2598
                            has_arg = 1;
2599
                        } else {
2600
                            has_arg = 0;
2601
                        }
2602
                    }
2603
                    typestr++;
2604
                    if (nb_args >= MAX_ARGS)
2605
                        goto error_args;
2606
                    args[nb_args++] = (void *)(long)has_arg;
2607
                    if (!has_arg) {
2608
                        if (nb_args >= MAX_ARGS)
2609
                            goto error_args;
2610
                        val = -1;
2611
                        goto add_num;
2612
                    }
2613
                }
2614
                if (get_expr(mon, &val, &p))
2615
                    goto fail;
2616
            add_num:
2617
                if (c == 'i') {
2618
                    if (nb_args >= MAX_ARGS)
2619
                        goto error_args;
2620
                    args[nb_args++] = (void *)(long)val;
2621
                } else {
2622
                    if ((nb_args + 1) >= MAX_ARGS)
2623
                        goto error_args;
2624
#if TARGET_PHYS_ADDR_BITS > 32
2625
                    args[nb_args++] = (void *)(long)((val >> 32) & 0xffffffff);
2626
#else
2627
                    args[nb_args++] = (void *)0;
2628
#endif
2629
                    args[nb_args++] = (void *)(long)(val & 0xffffffff);
2630
                }
2631
            }
2632
            break;
2633
        case '-':
2634
            {
2635
                int has_option;
2636
                /* option */
2637

    
2638
                c = *typestr++;
2639
                if (c == '\0')
2640
                    goto bad_type;
2641
                while (qemu_isspace(*p))
2642
                    p++;
2643
                has_option = 0;
2644
                if (*p == '-') {
2645
                    p++;
2646
                    if (*p != c) {
2647
                        monitor_printf(mon, "%s: unsupported option -%c\n",
2648
                                       cmdname, *p);
2649
                        goto fail;
2650
                    }
2651
                    p++;
2652
                    has_option = 1;
2653
                }
2654
                if (nb_args >= MAX_ARGS)
2655
                    goto error_args;
2656
                args[nb_args++] = (void *)(long)has_option;
2657
            }
2658
            break;
2659
        default:
2660
        bad_type:
2661
            monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
2662
            goto fail;
2663
        }
2664
    }
2665
    /* check that all arguments were parsed */
2666
    while (qemu_isspace(*p))
2667
        p++;
2668
    if (*p != '\0') {
2669
        monitor_printf(mon, "%s: extraneous characters at the end of line\n",
2670
                       cmdname);
2671
        goto fail;
2672
    }
2673

    
2674
    switch(nb_args) {
2675
    case 0:
2676
        handler_0 = cmd->handler;
2677
        handler_0(mon);
2678
        break;
2679
    case 1:
2680
        handler_1 = cmd->handler;
2681
        handler_1(mon, args[0]);
2682
        break;
2683
    case 2:
2684
        handler_2 = cmd->handler;
2685
        handler_2(mon, args[0], args[1]);
2686
        break;
2687
    case 3:
2688
        handler_3 = cmd->handler;
2689
        handler_3(mon, args[0], args[1], args[2]);
2690
        break;
2691
    case 4:
2692
        handler_4 = cmd->handler;
2693
        handler_4(mon, args[0], args[1], args[2], args[3]);
2694
        break;
2695
    case 5:
2696
        handler_5 = cmd->handler;
2697
        handler_5(mon, args[0], args[1], args[2], args[3], args[4]);
2698
        break;
2699
    case 6:
2700
        handler_6 = cmd->handler;
2701
        handler_6(mon, args[0], args[1], args[2], args[3], args[4], args[5]);
2702
        break;
2703
    case 7:
2704
        handler_7 = cmd->handler;
2705
        handler_7(mon, args[0], args[1], args[2], args[3], args[4], args[5],
2706
                  args[6]);
2707
        break;
2708
    default:
2709
        monitor_printf(mon, "unsupported number of arguments: %d\n", nb_args);
2710
        goto fail;
2711
    }
2712
 fail:
2713
    for(i = 0; i < MAX_ARGS; i++)
2714
        qemu_free(str_allocated[i]);
2715
    return;
2716
}
2717

    
2718
static void cmd_completion(const char *name, const char *list)
2719
{
2720
    const char *p, *pstart;
2721
    char cmd[128];
2722
    int len;
2723

    
2724
    p = list;
2725
    for(;;) {
2726
        pstart = p;
2727
        p = strchr(p, '|');
2728
        if (!p)
2729
            p = pstart + strlen(pstart);
2730
        len = p - pstart;
2731
        if (len > sizeof(cmd) - 2)
2732
            len = sizeof(cmd) - 2;
2733
        memcpy(cmd, pstart, len);
2734
        cmd[len] = '\0';
2735
        if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
2736
            readline_add_completion(cur_mon->rs, cmd);
2737
        }
2738
        if (*p == '\0')
2739
            break;
2740
        p++;
2741
    }
2742
}
2743

    
2744
static void file_completion(const char *input)
2745
{
2746
    DIR *ffs;
2747
    struct dirent *d;
2748
    char path[1024];
2749
    char file[1024], file_prefix[1024];
2750
    int input_path_len;
2751
    const char *p;
2752

    
2753
    p = strrchr(input, '/');
2754
    if (!p) {
2755
        input_path_len = 0;
2756
        pstrcpy(file_prefix, sizeof(file_prefix), input);
2757
        pstrcpy(path, sizeof(path), ".");
2758
    } else {
2759
        input_path_len = p - input + 1;
2760
        memcpy(path, input, input_path_len);
2761
        if (input_path_len > sizeof(path) - 1)
2762
            input_path_len = sizeof(path) - 1;
2763
        path[input_path_len] = '\0';
2764
        pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
2765
    }
2766
#ifdef DEBUG_COMPLETION
2767
    monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
2768
                   input, path, file_prefix);
2769
#endif
2770
    ffs = opendir(path);
2771
    if (!ffs)
2772
        return;
2773
    for(;;) {
2774
        struct stat sb;
2775
        d = readdir(ffs);
2776
        if (!d)
2777
            break;
2778
        if (strstart(d->d_name, file_prefix, NULL)) {
2779
            memcpy(file, input, input_path_len);
2780
            if (input_path_len < sizeof(file))
2781
                pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
2782
                        d->d_name);
2783
            /* stat the file to find out if it's a directory.
2784
             * In that case add a slash to speed up typing long paths
2785
             */
2786
            stat(file, &sb);
2787
            if(S_ISDIR(sb.st_mode))
2788
                pstrcat(file, sizeof(file), "/");
2789
            readline_add_completion(cur_mon->rs, file);
2790
        }
2791
    }
2792
    closedir(ffs);
2793
}
2794

    
2795
static void block_completion_it(void *opaque, BlockDriverState *bs)
2796
{
2797
    const char *name = bdrv_get_device_name(bs);
2798
    const char *input = opaque;
2799

    
2800
    if (input[0] == '\0' ||
2801
        !strncmp(name, (char *)input, strlen(input))) {
2802
        readline_add_completion(cur_mon->rs, name);
2803
    }
2804
}
2805

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

    
2814
    p = cmdline;
2815
    nb_args = 0;
2816
    for(;;) {
2817
        while (qemu_isspace(*p))
2818
            p++;
2819
        if (*p == '\0')
2820
            break;
2821
        if (nb_args >= MAX_ARGS)
2822
            break;
2823
        ret = get_str(buf, sizeof(buf), &p);
2824
        args[nb_args] = qemu_strdup(buf);
2825
        nb_args++;
2826
        if (ret < 0)
2827
            break;
2828
    }
2829
    *pnb_args = nb_args;
2830
}
2831

    
2832
static void monitor_find_completion(const char *cmdline)
2833
{
2834
    const char *cmdname;
2835
    char *args[MAX_ARGS];
2836
    int nb_args, i, len;
2837
    const char *ptype, *str;
2838
    const mon_cmd_t *cmd;
2839
    const KeyDef *key;
2840

    
2841
    parse_cmdline(cmdline, &nb_args, args);
2842
#ifdef DEBUG_COMPLETION
2843
    for(i = 0; i < nb_args; i++) {
2844
        monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
2845
    }
2846
#endif
2847

    
2848
    /* if the line ends with a space, it means we want to complete the
2849
       next arg */
2850
    len = strlen(cmdline);
2851
    if (len > 0 && qemu_isspace(cmdline[len - 1])) {
2852
        if (nb_args >= MAX_ARGS)
2853
            return;
2854
        args[nb_args++] = qemu_strdup("");
2855
    }
2856
    if (nb_args <= 1) {
2857
        /* command completion */
2858
        if (nb_args == 0)
2859
            cmdname = "";
2860
        else
2861
            cmdname = args[0];
2862
        readline_set_completion_index(cur_mon->rs, strlen(cmdname));
2863
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
2864
            cmd_completion(cmdname, cmd->name);
2865
        }
2866
    } else {
2867
        /* find the command */
2868
        for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
2869
            if (compare_cmd(args[0], cmd->name))
2870
                goto found;
2871
        }
2872
        return;
2873
    found:
2874
        ptype = cmd->args_type;
2875
        for(i = 0; i < nb_args - 2; i++) {
2876
            if (*ptype != '\0') {
2877
                ptype++;
2878
                while (*ptype == '?')
2879
                    ptype++;
2880
            }
2881
        }
2882
        str = args[nb_args - 1];
2883
        switch(*ptype) {
2884
        case 'F':
2885
            /* file completion */
2886
            readline_set_completion_index(cur_mon->rs, strlen(str));
2887
            file_completion(str);
2888
            break;
2889
        case 'B':
2890
            /* block device name completion */
2891
            readline_set_completion_index(cur_mon->rs, strlen(str));
2892
            bdrv_iterate(block_completion_it, (void *)str);
2893
            break;
2894
        case 's':
2895
            /* XXX: more generic ? */
2896
            if (!strcmp(cmd->name, "info")) {
2897
                readline_set_completion_index(cur_mon->rs, strlen(str));
2898
                for(cmd = info_cmds; cmd->name != NULL; cmd++) {
2899
                    cmd_completion(str, cmd->name);
2900
                }
2901
            } else if (!strcmp(cmd->name, "sendkey")) {
2902
                char *sep = strrchr(str, '-');
2903
                if (sep)
2904
                    str = sep + 1;
2905
                readline_set_completion_index(cur_mon->rs, strlen(str));
2906
                for(key = key_defs; key->name != NULL; key++) {
2907
                    cmd_completion(str, key->name);
2908
                }
2909
            }
2910
            break;
2911
        default:
2912
            break;
2913
        }
2914
    }
2915
    for(i = 0; i < nb_args; i++)
2916
        qemu_free(args[i]);
2917
}
2918

    
2919
static int monitor_can_read(void *opaque)
2920
{
2921
    Monitor *mon = opaque;
2922

    
2923
    return (mon->suspend_cnt == 0) ? 128 : 0;
2924
}
2925

    
2926
static void monitor_read(void *opaque, const uint8_t *buf, int size)
2927
{
2928
    Monitor *old_mon = cur_mon;
2929
    int i;
2930

    
2931
    cur_mon = opaque;
2932

    
2933
    if (cur_mon->rs) {
2934
        for (i = 0; i < size; i++)
2935
            readline_handle_byte(cur_mon->rs, buf[i]);
2936
    } else {
2937
        if (size == 0 || buf[size - 1] != 0)
2938
            monitor_printf(cur_mon, "corrupted command\n");
2939
        else
2940
            monitor_handle_command(cur_mon, (char *)buf);
2941
    }
2942

    
2943
    cur_mon = old_mon;
2944
}
2945

    
2946
static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
2947
{
2948
    monitor_suspend(mon);
2949
    monitor_handle_command(mon, cmdline);
2950
    monitor_resume(mon);
2951
}
2952

    
2953
int monitor_suspend(Monitor *mon)
2954
{
2955
    if (!mon->rs)
2956
        return -ENOTTY;
2957
    mon->suspend_cnt++;
2958
    return 0;
2959
}
2960

    
2961
void monitor_resume(Monitor *mon)
2962
{
2963
    if (!mon->rs)
2964
        return;
2965
    if (--mon->suspend_cnt == 0)
2966
        readline_show_prompt(mon->rs);
2967
}
2968

    
2969
static void monitor_event(void *opaque, int event)
2970
{
2971
    Monitor *mon = opaque;
2972

    
2973
    switch (event) {
2974
    case CHR_EVENT_MUX_IN:
2975
        readline_restart(mon->rs);
2976
        monitor_resume(mon);
2977
        monitor_flush(mon);
2978
        break;
2979

    
2980
    case CHR_EVENT_MUX_OUT:
2981
        if (mon->suspend_cnt == 0)
2982
            monitor_printf(mon, "\n");
2983
        monitor_flush(mon);
2984
        monitor_suspend(mon);
2985
        break;
2986

    
2987
    case CHR_EVENT_RESET:
2988
        monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
2989
                       "information\n", QEMU_VERSION);
2990
        if (mon->chr->focus == 0)
2991
            readline_show_prompt(mon->rs);
2992
        break;
2993
    }
2994
}
2995

    
2996

    
2997
/*
2998
 * Local variables:
2999
 *  c-indent-level: 4
3000
 *  c-basic-offset: 4
3001
 *  tab-width: 8
3002
 * End:
3003
 */
3004

    
3005
void monitor_init(CharDriverState *chr, int flags)
3006
{
3007
    static int is_first_init = 1;
3008
    Monitor *mon;
3009

    
3010
    if (is_first_init) {
3011
        key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
3012
        is_first_init = 0;
3013
    }
3014

    
3015
    mon = qemu_mallocz(sizeof(*mon));
3016

    
3017
    mon->chr = chr;
3018
    mon->flags = flags;
3019
    if (mon->chr->focus != 0)
3020
        mon->suspend_cnt = 1; /* mux'ed monitors start suspended */
3021
    if (flags & MONITOR_USE_READLINE) {
3022
        mon->rs = readline_init(mon, monitor_find_completion);
3023
        monitor_read_command(mon, 0);
3024
    }
3025

    
3026
    qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event,
3027
                          mon);
3028

    
3029
    LIST_INSERT_HEAD(&mon_list, mon, entry);
3030
    if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
3031
        cur_mon = mon;
3032
}
3033

    
3034
static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
3035
{
3036
    BlockDriverState *bs = opaque;
3037
    int ret = 0;
3038

    
3039
    if (bdrv_set_key(bs, password) != 0) {
3040
        monitor_printf(mon, "invalid password\n");
3041
        ret = -EPERM;
3042
    }
3043
    if (mon->password_completion_cb)
3044
        mon->password_completion_cb(mon->password_opaque, ret);
3045

    
3046
    monitor_read_command(mon, 1);
3047
}
3048

    
3049
void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
3050
                                 BlockDriverCompletionFunc *completion_cb,
3051
                                 void *opaque)
3052
{
3053
    int err;
3054

    
3055
    if (!bdrv_key_required(bs)) {
3056
        if (completion_cb)
3057
            completion_cb(opaque, 0);
3058
        return;
3059
    }
3060

    
3061
    monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
3062
                   bdrv_get_encrypted_filename(bs));
3063

    
3064
    mon->password_completion_cb = completion_cb;
3065
    mon->password_opaque = opaque;
3066

    
3067
    err = monitor_read_password(mon, bdrv_password_cb, bs);
3068

    
3069
    if (err && completion_cb)
3070
        completion_cb(opaque, err);
3071
}