Statistics
| Branch: | Revision:

root / monitor.c @ 5fafdf24

History | View | Annotate | Download (66.2 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 "vl.h"
25
#include "disas.h"
26
#include <dirent.h>
27

    
28
//#define DEBUG
29
//#define DEBUG_COMPLETION
30

    
31
#ifndef offsetof
32
#define offsetof(type, field) ((size_t) &((type *)0)->field)
33
#endif
34

    
35
/*
36
 * Supported types:
37
 *
38
 * 'F'          filename
39
 * 'B'          block device name
40
 * 's'          string (accept optional quote)
41
 * 'i'          32 bit integer
42
 * 'l'          target long (32 or 64 bit)
43
 * '/'          optional gdb-like print format (like "/10x")
44
 *
45
 * '?'          optional type (for 'F', 's' and 'i')
46
 *
47
 */
48

    
49
typedef struct term_cmd_t {
50
    const char *name;
51
    const char *args_type;
52
    void (*handler)();
53
    const char *params;
54
    const char *help;
55
} term_cmd_t;
56

    
57
#define MAX_MON 4
58
static CharDriverState *monitor_hd[MAX_MON];
59
static int hide_banner;
60

    
61
static term_cmd_t term_cmds[];
62
static term_cmd_t info_cmds[];
63

    
64
static char term_outbuf[1024];
65
static int term_outbuf_index;
66

    
67
static void monitor_start_input(void);
68

    
69
CPUState *mon_cpu = NULL;
70

    
71
void term_flush(void)
72
{
73
    int i;
74
    if (term_outbuf_index > 0) {
75
        for (i = 0; i < MAX_MON; i++)
76
            if (monitor_hd[i] && monitor_hd[i]->focus == 0)
77
                qemu_chr_write(monitor_hd[i], term_outbuf, term_outbuf_index);
78
        term_outbuf_index = 0;
79
    }
80
}
81

    
82
/* flush at every end of line or if the buffer is full */
83
void term_puts(const char *str)
84
{
85
    int c;
86
    for(;;) {
87
        c = *str++;
88
        if (c == '\0')
89
            break;
90
        if (c == '\n')
91
            term_outbuf[term_outbuf_index++] = '\r';
92
        term_outbuf[term_outbuf_index++] = c;
93
        if (term_outbuf_index >= (sizeof(term_outbuf) - 1) ||
94
            c == '\n')
95
            term_flush();
96
    }
97
}
98

    
99
void term_vprintf(const char *fmt, va_list ap)
100
{
101
    char buf[4096];
102
    vsnprintf(buf, sizeof(buf), fmt, ap);
103
    term_puts(buf);
104
}
105

    
106
void term_printf(const char *fmt, ...)
107
{
108
    va_list ap;
109
    va_start(ap, fmt);
110
    term_vprintf(fmt, ap);
111
    va_end(ap);
112
}
113

    
114
void term_print_filename(const char *filename)
115
{
116
    int i;
117

    
118
    for (i = 0; filename[i]; i++) {
119
        switch (filename[i]) {
120
        case ' ':
121
        case '"':
122
        case '\\':
123
            term_printf("\\%c", filename[i]);
124
            break;
125
        case '\t':
126
            term_printf("\\t");
127
            break;
128
        case '\r':
129
            term_printf("\\r");
130
            break;
131
        case '\n':
132
            term_printf("\\n");
133
            break;
134
        default:
135
            term_printf("%c", filename[i]);
136
            break;
137
        }
138
    }
139
}
140

    
141
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
142
{
143
    va_list ap;
144
    va_start(ap, fmt);
145
    term_vprintf(fmt, ap);
146
    va_end(ap);
147
    return 0;
148
}
149

    
150
static int compare_cmd(const char *name, const char *list)
151
{
152
    const char *p, *pstart;
153
    int len;
154
    len = strlen(name);
155
    p = list;
156
    for(;;) {
157
        pstart = p;
158
        p = strchr(p, '|');
159
        if (!p)
160
            p = pstart + strlen(pstart);
161
        if ((p - pstart) == len && !memcmp(pstart, name, len))
162
            return 1;
163
        if (*p == '\0')
164
            break;
165
        p++;
166
    }
167
    return 0;
168
}
169

    
170
static void help_cmd1(term_cmd_t *cmds, const char *prefix, const char *name)
171
{
172
    term_cmd_t *cmd;
173

    
174
    for(cmd = cmds; cmd->name != NULL; cmd++) {
175
        if (!name || !strcmp(name, cmd->name))
176
            term_printf("%s%s %s -- %s\n", prefix, cmd->name, cmd->params, cmd->help);
177
    }
178
}
179

    
180
static void help_cmd(const char *name)
181
{
182
    if (name && !strcmp(name, "info")) {
183
        help_cmd1(info_cmds, "info ", NULL);
184
    } else {
185
        help_cmd1(term_cmds, "", name);
186
        if (name && !strcmp(name, "log")) {
187
            CPULogItem *item;
188
            term_printf("Log items (comma separated):\n");
189
            term_printf("%-10s %s\n", "none", "remove all logs");
190
            for(item = cpu_log_items; item->mask != 0; item++) {
191
                term_printf("%-10s %s\n", item->name, item->help);
192
            }
193
        }
194
    }
195
}
196

    
197
static void do_help(const char *name)
198
{
199
    help_cmd(name);
200
}
201

    
202
static void do_commit(const char *device)
203
{
204
    int i, all_devices;
205

    
206
    all_devices = !strcmp(device, "all");
207
    for (i = 0; i < MAX_DISKS; i++) {
208
        if (bs_table[i]) {
209
            if (all_devices ||
210
                !strcmp(bdrv_get_device_name(bs_table[i]), device))
211
                bdrv_commit(bs_table[i]);
212
        }
213
    }
214
    if (mtd_bdrv)
215
        if (all_devices || !strcmp(bdrv_get_device_name(mtd_bdrv), device))
216
            bdrv_commit(mtd_bdrv);
217
}
218

    
219
static void do_info(const char *item)
220
{
221
    term_cmd_t *cmd;
222

    
223
    if (!item)
224
        goto help;
225
    for(cmd = info_cmds; cmd->name != NULL; cmd++) {
226
        if (compare_cmd(item, cmd->name))
227
            goto found;
228
    }
229
 help:
230
    help_cmd("info");
231
    return;
232
 found:
233
    cmd->handler();
234
}
235

    
236
static void do_info_version(void)
237
{
238
  term_printf("%s\n", QEMU_VERSION);
239
}
240

    
241
static void do_info_name(void)
242
{
243
    if (qemu_name)
244
        term_printf("%s\n", qemu_name);
245
}
246

    
247
static void do_info_block(void)
248
{
249
    bdrv_info();
250
}
251

    
252
/* get the current CPU defined by the user */
253
int mon_set_cpu(int cpu_index)
254
{
255
    CPUState *env;
256

    
257
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
258
        if (env->cpu_index == cpu_index) {
259
            mon_cpu = env;
260
            return 0;
261
        }
262
    }
263
    return -1;
264
}
265

    
266
CPUState *mon_get_cpu(void)
267
{
268
    if (!mon_cpu) {
269
        mon_set_cpu(0);
270
    }
271
    return mon_cpu;
272
}
273

    
274
static void do_info_registers(void)
275
{
276
    CPUState *env;
277
    env = mon_get_cpu();
278
    if (!env)
279
        return;
280
#ifdef TARGET_I386
281
    cpu_dump_state(env, NULL, monitor_fprintf,
282
                   X86_DUMP_FPU);
283
#else
284
    cpu_dump_state(env, NULL, monitor_fprintf,
285
                   0);
286
#endif
287
}
288

    
289
static void do_info_cpus(void)
290
{
291
    CPUState *env;
292

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

    
296
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
297
        term_printf("%c CPU #%d:",
298
                    (env == mon_cpu) ? '*' : ' ',
299
                    env->cpu_index);
300
#if defined(TARGET_I386)
301
        term_printf(" pc=0x" TARGET_FMT_lx, env->eip + env->segs[R_CS].base);
302
        if (env->hflags & HF_HALTED_MASK)
303
            term_printf(" (halted)");
304
#elif defined(TARGET_PPC)
305
        term_printf(" nip=0x" TARGET_FMT_lx, env->nip);
306
        if (env->halted)
307
            term_printf(" (halted)");
308
#elif defined(TARGET_SPARC)
309
        term_printf(" pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx, env->pc, env->npc);
310
        if (env->halted)
311
            term_printf(" (halted)");
312
#elif defined(TARGET_MIPS)
313
        term_printf(" PC=0x" TARGET_FMT_lx, env->PC[env->current_tc]);
314
        if (env->halted)
315
            term_printf(" (halted)");
316
#endif
317
        term_printf("\n");
318
    }
319
}
320

    
321
static void do_cpu_set(int index)
322
{
323
    if (mon_set_cpu(index) < 0)
324
        term_printf("Invalid CPU index\n");
325
}
326

    
327
static void do_info_jit(void)
328
{
329
    dump_exec_info(NULL, monitor_fprintf);
330
}
331

    
332
static void do_info_history (void)
333
{
334
    int i;
335
    const char *str;
336
   
337
    i = 0;
338
    for(;;) {
339
        str = readline_get_history(i);
340
        if (!str)
341
            break;
342
        term_printf("%d: '%s'\n", i, str);
343
        i++;
344
    }
345
}
346

    
347
#if defined(TARGET_PPC)
348
/* XXX: not implemented in other targets */
349
static void do_info_cpu_stats (void)
350
{
351
    CPUState *env;
352

    
353
    env = mon_get_cpu();
354
    cpu_dump_statistics(env, NULL, &monitor_fprintf, 0);
355
}
356
#endif
357

    
358
static void do_quit(void)
359
{
360
    exit(0);
361
}
362

    
363
static int eject_device(BlockDriverState *bs, int force)
364
{
365
    if (bdrv_is_inserted(bs)) {
366
        if (!force) {
367
            if (!bdrv_is_removable(bs)) {
368
                term_printf("device is not removable\n");
369
                return -1;
370
            }
371
            if (bdrv_is_locked(bs)) {
372
                term_printf("device is locked\n");
373
                return -1;
374
            }
375
        }
376
        bdrv_close(bs);
377
    }
378
    return 0;
379
}
380

    
381
static void do_eject(int force, const char *filename)
382
{
383
    BlockDriverState *bs;
384

    
385
    bs = bdrv_find(filename);
386
    if (!bs) {
387
        term_printf("device not found\n");
388
        return;
389
    }
390
    eject_device(bs, force);
391
}
392

    
393
static void do_change_block(const char *device, const char *filename)
394
{
395
    BlockDriverState *bs;
396

    
397
    bs = bdrv_find(device);
398
    if (!bs) {
399
        term_printf("device not found\n");
400
        return;
401
    }
402
    if (eject_device(bs, 0) < 0)
403
        return;
404
    bdrv_open(bs, filename, 0);
405
    qemu_key_check(bs, filename);
406
}
407

    
408
static void do_change_vnc(const char *target)
409
{
410
    if (strcmp(target, "passwd") == 0 ||
411
        strcmp(target, "password") == 0) {
412
        char password[9];
413
        monitor_readline("Password: ", 1, password, sizeof(password)-1);
414
        password[sizeof(password)-1] = '\0';
415
        if (vnc_display_password(NULL, password) < 0)
416
            term_printf("could not set VNC server password\n");
417
    } else {
418
        if (vnc_display_open(NULL, target) < 0)
419
            term_printf("could not start VNC server on %s\n", target);
420
    }
421
}
422

    
423
static void do_change(const char *device, const char *target)
424
{
425
    if (strcmp(device, "vnc") == 0) {
426
        do_change_vnc(target);
427
    } else {
428
        do_change_block(device, target);
429
    }
430
}
431

    
432
static void do_screen_dump(const char *filename)
433
{
434
    vga_hw_screen_dump(filename);
435
}
436

    
437
static void do_logfile(const char *filename)
438
{
439
    cpu_set_log_filename(filename);
440
}
441

    
442
static void do_log(const char *items)
443
{
444
    int mask;
445
   
446
    if (!strcmp(items, "none")) {
447
        mask = 0;
448
    } else {
449
        mask = cpu_str_to_log_mask(items);
450
        if (!mask) {
451
            help_cmd("log");
452
            return;
453
        }
454
    }
455
    cpu_set_log(mask);
456
}
457

    
458
static void do_stop(void)
459
{
460
    vm_stop(EXCP_INTERRUPT);
461
}
462

    
463
static void do_cont(void)
464
{
465
    vm_start();
466
}
467

    
468
#ifdef CONFIG_GDBSTUB
469
static void do_gdbserver(const char *port)
470
{
471
    if (!port)
472
        port = DEFAULT_GDBSTUB_PORT;
473
    if (gdbserver_start(port) < 0) {
474
        qemu_printf("Could not open gdbserver socket on port '%s'\n", port);
475
    } else {
476
        qemu_printf("Waiting gdb connection on port '%s'\n", port);
477
    }
478
}
479
#endif
480

    
481
static void term_printc(int c)
482
{
483
    term_printf("'");
484
    switch(c) {
485
    case '\'':
486
        term_printf("\\'");
487
        break;
488
    case '\\':
489
        term_printf("\\\\");
490
        break;
491
    case '\n':
492
        term_printf("\\n");
493
        break;
494
    case '\r':
495
        term_printf("\\r");
496
        break;
497
    default:
498
        if (c >= 32 && c <= 126) {
499
            term_printf("%c", c);
500
        } else {
501
            term_printf("\\x%02x", c);
502
        }
503
        break;
504
    }
505
    term_printf("'");
506
}
507

    
508
static void memory_dump(int count, int format, int wsize,
509
                        target_ulong addr, int is_physical)
510
{
511
    CPUState *env;
512
    int nb_per_line, l, line_size, i, max_digits, len;
513
    uint8_t buf[16];
514
    uint64_t v;
515

    
516
    if (format == 'i') {
517
        int flags;
518
        flags = 0;
519
        env = mon_get_cpu();
520
        if (!env && !is_physical)
521
            return;
522
#ifdef TARGET_I386
523
        if (wsize == 2) {
524
            flags = 1;
525
        } else if (wsize == 4) {
526
            flags = 0;
527
        } else {
528
            /* as default we use the current CS size */
529
            flags = 0;
530
            if (env) {
531
#ifdef TARGET_X86_64
532
                if ((env->efer & MSR_EFER_LMA) &&
533
                    (env->segs[R_CS].flags & DESC_L_MASK))
534
                    flags = 2;
535
                else
536
#endif
537
                if (!(env->segs[R_CS].flags & DESC_B_MASK))
538
                    flags = 1;
539
            }
540
        }
541
#endif
542
        monitor_disas(env, addr, count, is_physical, flags);
543
        return;
544
    }
545

    
546
    len = wsize * count;
547
    if (wsize == 1)
548
        line_size = 8;
549
    else
550
        line_size = 16;
551
    nb_per_line = line_size / wsize;
552
    max_digits = 0;
553

    
554
    switch(format) {
555
    case 'o':
556
        max_digits = (wsize * 8 + 2) / 3;
557
        break;
558
    default:
559
    case 'x':
560
        max_digits = (wsize * 8) / 4;
561
        break;
562
    case 'u':
563
    case 'd':
564
        max_digits = (wsize * 8 * 10 + 32) / 33;
565
        break;
566
    case 'c':
567
        wsize = 1;
568
        break;
569
    }
570

    
571
    while (len > 0) {
572
        term_printf(TARGET_FMT_lx ":", addr);
573
        l = len;
574
        if (l > line_size)
575
            l = line_size;
576
        if (is_physical) {
577
            cpu_physical_memory_rw(addr, buf, l, 0);
578
        } else {
579
            env = mon_get_cpu();
580
            if (!env)
581
                break;
582
            cpu_memory_rw_debug(env, addr, buf, l, 0);
583
        }
584
        i = 0;
585
        while (i < l) {
586
            switch(wsize) {
587
            default:
588
            case 1:
589
                v = ldub_raw(buf + i);
590
                break;
591
            case 2:
592
                v = lduw_raw(buf + i);
593
                break;
594
            case 4:
595
                v = (uint32_t)ldl_raw(buf + i);
596
                break;
597
            case 8:
598
                v = ldq_raw(buf + i);
599
                break;
600
            }
601
            term_printf(" ");
602
            switch(format) {
603
            case 'o':
604
                term_printf("%#*" PRIo64, max_digits, v);
605
                break;
606
            case 'x':
607
                term_printf("0x%0*" PRIx64, max_digits, v);
608
                break;
609
            case 'u':
610
                term_printf("%*" PRIu64, max_digits, v);
611
                break;
612
            case 'd':
613
                term_printf("%*" PRId64, max_digits, v);
614
                break;
615
            case 'c':
616
                term_printc(v);
617
                break;
618
            }
619
            i += wsize;
620
        }
621
        term_printf("\n");
622
        addr += l;
623
        len -= l;
624
    }
625
}
626

    
627
#if TARGET_LONG_BITS == 64
628
#define GET_TLONG(h, l) (((uint64_t)(h) << 32) | (l))
629
#else
630
#define GET_TLONG(h, l) (l)
631
#endif
632

    
633
static void do_memory_dump(int count, int format, int size,
634
                           uint32_t addrh, uint32_t addrl)
635
{
636
    target_long addr = GET_TLONG(addrh, addrl);
637
    memory_dump(count, format, size, addr, 0);
638
}
639

    
640
static void do_physical_memory_dump(int count, int format, int size,
641
                                    uint32_t addrh, uint32_t addrl)
642

    
643
{
644
    target_long addr = GET_TLONG(addrh, addrl);
645
    memory_dump(count, format, size, addr, 1);
646
}
647

    
648
static void do_print(int count, int format, int size, unsigned int valh, unsigned int vall)
649
{
650
    target_long val = GET_TLONG(valh, vall);
651
#if TARGET_LONG_BITS == 32
652
    switch(format) {
653
    case 'o':
654
        term_printf("%#o", val);
655
        break;
656
    case 'x':
657
        term_printf("%#x", val);
658
        break;
659
    case 'u':
660
        term_printf("%u", val);
661
        break;
662
    default:
663
    case 'd':
664
        term_printf("%d", val);
665
        break;
666
    case 'c':
667
        term_printc(val);
668
        break;
669
    }
670
#else
671
    switch(format) {
672
    case 'o':
673
        term_printf("%#" PRIo64, val);
674
        break;
675
    case 'x':
676
        term_printf("%#" PRIx64, val);
677
        break;
678
    case 'u':
679
        term_printf("%" PRIu64, val);
680
        break;
681
    default:
682
    case 'd':
683
        term_printf("%" PRId64, val);
684
        break;
685
    case 'c':
686
        term_printc(val);
687
        break;
688
    }
689
#endif
690
    term_printf("\n");
691
}
692

    
693
static void do_memory_save(unsigned int valh, unsigned int vall,
694
                           uint32_t size, const char *filename)
695
{
696
    FILE *f;
697
    target_long addr = GET_TLONG(valh, vall);
698
    uint32_t l;
699
    CPUState *env;
700
    uint8_t buf[1024];
701

    
702
    env = mon_get_cpu();
703
    if (!env)
704
        return;
705

    
706
    f = fopen(filename, "wb");
707
    if (!f) {
708
        term_printf("could not open '%s'\n", filename);
709
        return;
710
    }
711
    while (size != 0) {
712
        l = sizeof(buf);
713
        if (l > size)
714
            l = size;
715
        cpu_memory_rw_debug(env, addr, buf, l, 0);
716
        fwrite(buf, 1, l, f);
717
        addr += l;
718
        size -= l;
719
    }
720
    fclose(f);
721
}
722

    
723
static void do_sum(uint32_t start, uint32_t size)
724
{
725
    uint32_t addr;
726
    uint8_t buf[1];
727
    uint16_t sum;
728

    
729
    sum = 0;
730
    for(addr = start; addr < (start + size); addr++) {
731
        cpu_physical_memory_rw(addr, buf, 1, 0);
732
        /* BSD sum algorithm ('sum' Unix command) */
733
        sum = (sum >> 1) | (sum << 15);
734
        sum += buf[0];
735
    }
736
    term_printf("%05d\n", sum);
737
}
738

    
739
typedef struct {
740
    int keycode;
741
    const char *name;
742
} KeyDef;
743

    
744
static const KeyDef key_defs[] = {
745
    { 0x2a, "shift" },
746
    { 0x36, "shift_r" },
747
   
748
    { 0x38, "alt" },
749
    { 0xb8, "alt_r" },
750
    { 0x1d, "ctrl" },
751
    { 0x9d, "ctrl_r" },
752

    
753
    { 0xdd, "menu" },
754

    
755
    { 0x01, "esc" },
756

    
757
    { 0x02, "1" },
758
    { 0x03, "2" },
759
    { 0x04, "3" },
760
    { 0x05, "4" },
761
    { 0x06, "5" },
762
    { 0x07, "6" },
763
    { 0x08, "7" },
764
    { 0x09, "8" },
765
    { 0x0a, "9" },
766
    { 0x0b, "0" },
767
    { 0x0c, "minus" },
768
    { 0x0d, "equal" },
769
    { 0x0e, "backspace" },
770

    
771
    { 0x0f, "tab" },
772
    { 0x10, "q" },
773
    { 0x11, "w" },
774
    { 0x12, "e" },
775
    { 0x13, "r" },
776
    { 0x14, "t" },
777
    { 0x15, "y" },
778
    { 0x16, "u" },
779
    { 0x17, "i" },
780
    { 0x18, "o" },
781
    { 0x19, "p" },
782

    
783
    { 0x1c, "ret" },
784

    
785
    { 0x1e, "a" },
786
    { 0x1f, "s" },
787
    { 0x20, "d" },
788
    { 0x21, "f" },
789
    { 0x22, "g" },
790
    { 0x23, "h" },
791
    { 0x24, "j" },
792
    { 0x25, "k" },
793
    { 0x26, "l" },
794

    
795
    { 0x2c, "z" },
796
    { 0x2d, "x" },
797
    { 0x2e, "c" },
798
    { 0x2f, "v" },
799
    { 0x30, "b" },
800
    { 0x31, "n" },
801
    { 0x32, "m" },
802
   
803
    { 0x39, "spc" },
804
    { 0x3a, "caps_lock" },
805
    { 0x3b, "f1" },
806
    { 0x3c, "f2" },
807
    { 0x3d, "f3" },
808
    { 0x3e, "f4" },
809
    { 0x3f, "f5" },
810
    { 0x40, "f6" },
811
    { 0x41, "f7" },
812
    { 0x42, "f8" },
813
    { 0x43, "f9" },
814
    { 0x44, "f10" },
815
    { 0x45, "num_lock" },
816
    { 0x46, "scroll_lock" },
817

    
818
    { 0xb5, "kp_divide" },
819
    { 0x37, "kp_multiply" },
820
    { 0x4a, "kp_subtract" },
821
    { 0x4e, "kp_add" },
822
    { 0x9c, "kp_enter" },
823
    { 0x53, "kp_decimal" },
824

    
825
    { 0x52, "kp_0" },
826
    { 0x4f, "kp_1" },
827
    { 0x50, "kp_2" },
828
    { 0x51, "kp_3" },
829
    { 0x4b, "kp_4" },
830
    { 0x4c, "kp_5" },
831
    { 0x4d, "kp_6" },
832
    { 0x47, "kp_7" },
833
    { 0x48, "kp_8" },
834
    { 0x49, "kp_9" },
835
   
836
    { 0x56, "<" },
837

    
838
    { 0x57, "f11" },
839
    { 0x58, "f12" },
840

    
841
    { 0xb7, "print" },
842

    
843
    { 0xc7, "home" },
844
    { 0xc9, "pgup" },
845
    { 0xd1, "pgdn" },
846
    { 0xcf, "end" },
847

    
848
    { 0xcb, "left" },
849
    { 0xc8, "up" },
850
    { 0xd0, "down" },
851
    { 0xcd, "right" },
852

    
853
    { 0xd2, "insert" },
854
    { 0xd3, "delete" },
855
    { 0, NULL },
856
};
857

    
858
static int get_keycode(const char *key)
859
{
860
    const KeyDef *p;
861
    char *endp;
862
    int ret;
863

    
864
    for(p = key_defs; p->name != NULL; p++) {
865
        if (!strcmp(key, p->name))
866
            return p->keycode;
867
    }
868
    if (strstart(key, "0x", NULL)) {
869
        ret = strtoul(key, &endp, 0);
870
        if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
871
            return ret;
872
    }
873
    return -1;
874
}
875

    
876
static void do_send_key(const char *string)
877
{
878
    char keybuf[16], *q;
879
    uint8_t keycodes[16];
880
    const char *p;
881
    int nb_keycodes, keycode, i;
882
   
883
    nb_keycodes = 0;
884
    p = string;
885
    while (*p != '\0') {
886
        q = keybuf;
887
        while (*p != '\0' && *p != '-') {
888
            if ((q - keybuf) < sizeof(keybuf) - 1) {
889
                *q++ = *p;
890
            }
891
            p++;
892
        }
893
        *q = '\0';
894
        keycode = get_keycode(keybuf);
895
        if (keycode < 0) {
896
            term_printf("unknown key: '%s'\n", keybuf);
897
            return;
898
        }
899
        keycodes[nb_keycodes++] = keycode;
900
        if (*p == '\0')
901
            break;
902
        p++;
903
    }
904
    /* key down events */
905
    for(i = 0; i < nb_keycodes; i++) {
906
        keycode = keycodes[i];
907
        if (keycode & 0x80)
908
            kbd_put_keycode(0xe0);
909
        kbd_put_keycode(keycode & 0x7f);
910
    }
911
    /* key up events */
912
    for(i = nb_keycodes - 1; i >= 0; i--) {
913
        keycode = keycodes[i];
914
        if (keycode & 0x80)
915
            kbd_put_keycode(0xe0);
916
        kbd_put_keycode(keycode | 0x80);
917
    }
918
}
919

    
920
static int mouse_button_state;
921

    
922
static void do_mouse_move(const char *dx_str, const char *dy_str,
923
                          const char *dz_str)
924
{
925
    int dx, dy, dz;
926
    dx = strtol(dx_str, NULL, 0);
927
    dy = strtol(dy_str, NULL, 0);
928
    dz = 0;
929
    if (dz_str)
930
        dz = strtol(dz_str, NULL, 0);
931
    kbd_mouse_event(dx, dy, dz, mouse_button_state);
932
}
933

    
934
static void do_mouse_button(int button_state)
935
{
936
    mouse_button_state = button_state;
937
    kbd_mouse_event(0, 0, 0, mouse_button_state);
938
}
939

    
940
static void do_ioport_read(int count, int format, int size, int addr, int has_index, int index)
941
{
942
    uint32_t val;
943
    int suffix;
944

    
945
    if (has_index) {
946
        cpu_outb(NULL, addr & 0xffff, index & 0xff);
947
        addr++;
948
    }
949
    addr &= 0xffff;
950

    
951
    switch(size) {
952
    default:
953
    case 1:
954
        val = cpu_inb(NULL, addr);
955
        suffix = 'b';
956
        break;
957
    case 2:
958
        val = cpu_inw(NULL, addr);
959
        suffix = 'w';
960
        break;
961
    case 4:
962
        val = cpu_inl(NULL, addr);
963
        suffix = 'l';
964
        break;
965
    }
966
    term_printf("port%c[0x%04x] = %#0*x\n",
967
                suffix, addr, size * 2, val);
968
}
969

    
970
static void do_system_reset(void)
971
{
972
    qemu_system_reset_request();
973
}
974

    
975
static void do_system_powerdown(void)
976
{
977
    qemu_system_powerdown_request();
978
}
979

    
980
#if defined(TARGET_I386)
981
static void print_pte(uint32_t addr, uint32_t pte, uint32_t mask)
982
{
983
    term_printf("%08x: %08x %c%c%c%c%c%c%c%c\n",
984
                addr,
985
                pte & mask,
986
                pte & PG_GLOBAL_MASK ? 'G' : '-',
987
                pte & PG_PSE_MASK ? 'P' : '-',
988
                pte & PG_DIRTY_MASK ? 'D' : '-',
989
                pte & PG_ACCESSED_MASK ? 'A' : '-',
990
                pte & PG_PCD_MASK ? 'C' : '-',
991
                pte & PG_PWT_MASK ? 'T' : '-',
992
                pte & PG_USER_MASK ? 'U' : '-',
993
                pte & PG_RW_MASK ? 'W' : '-');
994
}
995

    
996
static void tlb_info(void)
997
{
998
    CPUState *env;
999
    int l1, l2;
1000
    uint32_t pgd, pde, pte;
1001

    
1002
    env = mon_get_cpu();
1003
    if (!env)
1004
        return;
1005

    
1006
    if (!(env->cr[0] & CR0_PG_MASK)) {
1007
        term_printf("PG disabled\n");
1008
        return;
1009
    }
1010
    pgd = env->cr[3] & ~0xfff;
1011
    for(l1 = 0; l1 < 1024; l1++) {
1012
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1013
        pde = le32_to_cpu(pde);
1014
        if (pde & PG_PRESENT_MASK) {
1015
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1016
                print_pte((l1 << 22), pde, ~((1 << 20) - 1));
1017
            } else {
1018
                for(l2 = 0; l2 < 1024; l2++) {
1019
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1020
                                             (uint8_t *)&pte, 4);
1021
                    pte = le32_to_cpu(pte);
1022
                    if (pte & PG_PRESENT_MASK) {
1023
                        print_pte((l1 << 22) + (l2 << 12),
1024
                                  pte & ~PG_PSE_MASK,
1025
                                  ~0xfff);
1026
                    }
1027
                }
1028
            }
1029
        }
1030
    }
1031
}
1032

    
1033
static void mem_print(uint32_t *pstart, int *plast_prot,
1034
                      uint32_t end, int prot)
1035
{
1036
    int prot1;
1037
    prot1 = *plast_prot;
1038
    if (prot != prot1) {
1039
        if (*pstart != -1) {
1040
            term_printf("%08x-%08x %08x %c%c%c\n",
1041
                        *pstart, end, end - *pstart,
1042
                        prot1 & PG_USER_MASK ? 'u' : '-',
1043
                        'r',
1044
                        prot1 & PG_RW_MASK ? 'w' : '-');
1045
        }
1046
        if (prot != 0)
1047
            *pstart = end;
1048
        else
1049
            *pstart = -1;
1050
        *plast_prot = prot;
1051
    }
1052
}
1053

    
1054
static void mem_info(void)
1055
{
1056
    CPUState *env;
1057
    int l1, l2, prot, last_prot;
1058
    uint32_t pgd, pde, pte, start, end;
1059

    
1060
    env = mon_get_cpu();
1061
    if (!env)
1062
        return;
1063

    
1064
    if (!(env->cr[0] & CR0_PG_MASK)) {
1065
        term_printf("PG disabled\n");
1066
        return;
1067
    }
1068
    pgd = env->cr[3] & ~0xfff;
1069
    last_prot = 0;
1070
    start = -1;
1071
    for(l1 = 0; l1 < 1024; l1++) {
1072
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1073
        pde = le32_to_cpu(pde);
1074
        end = l1 << 22;
1075
        if (pde & PG_PRESENT_MASK) {
1076
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1077
                prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1078
                mem_print(&start, &last_prot, end, prot);
1079
            } else {
1080
                for(l2 = 0; l2 < 1024; l2++) {
1081
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1082
                                             (uint8_t *)&pte, 4);
1083
                    pte = le32_to_cpu(pte);
1084
                    end = (l1 << 22) + (l2 << 12);
1085
                    if (pte & PG_PRESENT_MASK) {
1086
                        prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1087
                    } else {
1088
                        prot = 0;
1089
                    }
1090
                    mem_print(&start, &last_prot, end, prot);
1091
                }
1092
            }
1093
        } else {
1094
            prot = 0;
1095
            mem_print(&start, &last_prot, end, prot);
1096
        }
1097
    }
1098
}
1099
#endif
1100

    
1101
static void do_info_kqemu(void)
1102
{
1103
#ifdef USE_KQEMU
1104
    CPUState *env;
1105
    int val;
1106
    val = 0;
1107
    env = mon_get_cpu();
1108
    if (!env) {
1109
        term_printf("No cpu initialized yet");
1110
        return;
1111
    }
1112
    val = env->kqemu_enabled;
1113
    term_printf("kqemu support: ");
1114
    switch(val) {
1115
    default:
1116
    case 0:
1117
        term_printf("disabled\n");
1118
        break;
1119
    case 1:
1120
        term_printf("enabled for user code\n");
1121
        break;
1122
    case 2:
1123
        term_printf("enabled for user and kernel code\n");
1124
        break;
1125
    }
1126
#else
1127
    term_printf("kqemu support: not compiled\n");
1128
#endif
1129
}
1130

    
1131
#ifdef CONFIG_PROFILER
1132

    
1133
int64_t kqemu_time;
1134
int64_t qemu_time;
1135
int64_t kqemu_exec_count;
1136
int64_t dev_time;
1137
int64_t kqemu_ret_int_count;
1138
int64_t kqemu_ret_excp_count;
1139
int64_t kqemu_ret_intr_count;
1140

    
1141
static void do_info_profile(void)
1142
{
1143
    int64_t total;
1144
    total = qemu_time;
1145
    if (total == 0)
1146
        total = 1;
1147
    term_printf("async time  %" PRId64 " (%0.3f)\n",
1148
                dev_time, dev_time / (double)ticks_per_sec);
1149
    term_printf("qemu time   %" PRId64 " (%0.3f)\n",
1150
                qemu_time, qemu_time / (double)ticks_per_sec);
1151
    term_printf("kqemu time  %" PRId64 " (%0.3f %0.1f%%) count=%" PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%" PRId64 "\n",
1152
                kqemu_time, kqemu_time / (double)ticks_per_sec,
1153
                kqemu_time / (double)total * 100.0,
1154
                kqemu_exec_count,
1155
                kqemu_ret_int_count,
1156
                kqemu_ret_excp_count,
1157
                kqemu_ret_intr_count);
1158
    qemu_time = 0;
1159
    kqemu_time = 0;
1160
    kqemu_exec_count = 0;
1161
    dev_time = 0;
1162
    kqemu_ret_int_count = 0;
1163
    kqemu_ret_excp_count = 0;
1164
    kqemu_ret_intr_count = 0;
1165
#ifdef USE_KQEMU
1166
    kqemu_record_dump();
1167
#endif
1168
}
1169
#else
1170
static void do_info_profile(void)
1171
{
1172
    term_printf("Internal profiler not compiled\n");
1173
}
1174
#endif
1175

    
1176
/* Capture support */
1177
static LIST_HEAD (capture_list_head, CaptureState) capture_head;
1178

    
1179
static void do_info_capture (void)
1180
{
1181
    int i;
1182
    CaptureState *s;
1183

    
1184
    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1185
        term_printf ("[%d]: ", i);
1186
        s->ops.info (s->opaque);
1187
    }
1188
}
1189

    
1190
static void do_stop_capture (int n)
1191
{
1192
    int i;
1193
    CaptureState *s;
1194

    
1195
    for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1196
        if (i == n) {
1197
            s->ops.destroy (s->opaque);
1198
            LIST_REMOVE (s, entries);
1199
            qemu_free (s);
1200
            return;
1201
        }
1202
    }
1203
}
1204

    
1205
#ifdef HAS_AUDIO
1206
int wav_start_capture (CaptureState *s, const char *path, int freq,
1207
                       int bits, int nchannels);
1208

    
1209
static void do_wav_capture (const char *path,
1210
                            int has_freq, int freq,
1211
                            int has_bits, int bits,
1212
                            int has_channels, int nchannels)
1213
{
1214
    CaptureState *s;
1215

    
1216
    s = qemu_mallocz (sizeof (*s));
1217
    if (!s) {
1218
        term_printf ("Not enough memory to add wave capture\n");
1219
        return;
1220
    }
1221

    
1222
    freq = has_freq ? freq : 44100;
1223
    bits = has_bits ? bits : 16;
1224
    nchannels = has_channels ? nchannels : 2;
1225

    
1226
    if (wav_start_capture (s, path, freq, bits, nchannels)) {
1227
        term_printf ("Faied to add wave capture\n");
1228
        qemu_free (s);
1229
    }
1230
    LIST_INSERT_HEAD (&capture_head, s, entries);
1231
}
1232
#endif
1233

    
1234
static term_cmd_t term_cmds[] = {
1235
    { "help|?", "s?", do_help,
1236
      "[cmd]", "show the help" },
1237
    { "commit", "s", do_commit,
1238
      "device|all", "commit changes to the disk images (if -snapshot is used) or backing files" },
1239
    { "info", "s?", do_info,
1240
      "subcommand", "show various information about the system state" },
1241
    { "q|quit", "", do_quit,
1242
      "", "quit the emulator" },
1243
    { "eject", "-fB", do_eject,
1244
      "[-f] device", "eject a removable medium (use -f to force it)" },
1245
    { "change", "BF", do_change,
1246
      "device filename", "change a removable medium" },
1247
    { "screendump", "F", do_screen_dump,
1248
      "filename", "save screen into PPM image 'filename'" },
1249
    { "logfile", "s", do_logfile,
1250
      "filename", "output logs to 'filename'" },
1251
    { "log", "s", do_log,
1252
      "item1[,...]", "activate logging of the specified items to '/tmp/qemu.log'" },
1253
    { "savevm", "s?", do_savevm,
1254
      "tag|id", "save a VM snapshot. If no tag or id are provided, a new snapshot is created" },
1255
    { "loadvm", "s", do_loadvm,
1256
      "tag|id", "restore a VM snapshot from its tag or id" },
1257
    { "delvm", "s", do_delvm,
1258
      "tag|id", "delete a VM snapshot from its tag or id" },
1259
    { "stop", "", do_stop,
1260
      "", "stop emulation", },
1261
    { "c|cont", "", do_cont,
1262
      "", "resume emulation", },
1263
#ifdef CONFIG_GDBSTUB
1264
    { "gdbserver", "s?", do_gdbserver,
1265
      "[port]", "start gdbserver session (default port=1234)", },
1266
#endif
1267
    { "x", "/l", do_memory_dump,
1268
      "/fmt addr", "virtual memory dump starting at 'addr'", },
1269
    { "xp", "/l", do_physical_memory_dump,
1270
      "/fmt addr", "physical memory dump starting at 'addr'", },
1271
    { "p|print", "/l", do_print,
1272
      "/fmt expr", "print expression value (use $reg for CPU register access)", },
1273
    { "i", "/ii.", do_ioport_read,
1274
      "/fmt addr", "I/O port read" },
1275

    
1276
    { "sendkey", "s", do_send_key,
1277
      "keys", "send keys to the VM (e.g. 'sendkey ctrl-alt-f1')" },
1278
    { "system_reset", "", do_system_reset,
1279
      "", "reset the system" },
1280
    { "system_powerdown", "", do_system_powerdown,
1281
      "", "send system power down event" },
1282
    { "sum", "ii", do_sum,
1283
      "addr size", "compute the checksum of a memory region" },
1284
    { "usb_add", "s", do_usb_add,
1285
      "device", "add USB device (e.g. 'host:bus.addr' or 'host:vendor_id:product_id')" },
1286
    { "usb_del", "s", do_usb_del,
1287
      "device", "remove USB device 'bus.addr'" },
1288
    { "cpu", "i", do_cpu_set,
1289
      "index", "set the default CPU" },
1290
    { "mouse_move", "sss?", do_mouse_move,
1291
      "dx dy [dz]", "send mouse move events" },
1292
    { "mouse_button", "i", do_mouse_button,
1293
      "state", "change mouse button state (1=L, 2=M, 4=R)" },
1294
    { "mouse_set", "i", do_mouse_set,
1295
      "index", "set which mouse device receives events" },
1296
#ifdef HAS_AUDIO
1297
    { "wavcapture", "si?i?i?", do_wav_capture,
1298
      "path [frequency bits channels]",
1299
      "capture audio to a wave file (default frequency=44100 bits=16 channels=2)" },
1300
#endif
1301
     { "stopcapture", "i", do_stop_capture,
1302
       "capture index", "stop capture" },
1303
    { "memsave", "lis", do_memory_save,
1304
      "addr size file", "save to disk virtual memory dump starting at 'addr' of size 'size'", },
1305
    { NULL, NULL, },
1306
};
1307

    
1308
static term_cmd_t info_cmds[] = {
1309
    { "version", "", do_info_version,
1310
      "", "show the version of qemu" },
1311
    { "network", "", do_info_network,
1312
      "", "show the network state" },
1313
    { "block", "", do_info_block,
1314
      "", "show the block devices" },
1315
    { "registers", "", do_info_registers,
1316
      "", "show the cpu registers" },
1317
    { "cpus", "", do_info_cpus,
1318
      "", "show infos for each CPU" },
1319
    { "history", "", do_info_history,
1320
      "", "show the command line history", },
1321
    { "irq", "", irq_info,
1322
      "", "show the interrupts statistics (if available)", },
1323
    { "pic", "", pic_info,
1324
      "", "show i8259 (PIC) state", },
1325
    { "pci", "", pci_info,
1326
      "", "show PCI info", },
1327
#if defined(TARGET_I386)
1328
    { "tlb", "", tlb_info,
1329
      "", "show virtual to physical memory mappings", },
1330
    { "mem", "", mem_info,
1331
      "", "show the active virtual memory mappings", },
1332
#endif
1333
    { "jit", "", do_info_jit,
1334
      "", "show dynamic compiler info", },
1335
    { "kqemu", "", do_info_kqemu,
1336
      "", "show kqemu information", },
1337
    { "usb", "", usb_info,
1338
      "", "show guest USB devices", },
1339
    { "usbhost", "", usb_host_info,
1340
      "", "show host USB devices", },
1341
    { "profile", "", do_info_profile,
1342
      "", "show profiling information", },
1343
    { "capture", "", do_info_capture,
1344
      "", "show capture information" },
1345
    { "snapshots", "", do_info_snapshots,
1346
      "", "show the currently saved VM snapshots" },
1347
    { "pcmcia", "", pcmcia_info,
1348
      "", "show guest PCMCIA status" },
1349
    { "mice", "", do_info_mice,
1350
      "", "show which guest mouse is receiving events" },
1351
    { "vnc", "", do_info_vnc,
1352
      "", "show the vnc server status"},
1353
    { "name", "", do_info_name,
1354
      "", "show the current VM name" },
1355
#if defined(TARGET_PPC)
1356
    { "cpustats", "", do_info_cpu_stats,
1357
      "", "show CPU statistics", },
1358
#endif
1359
    { NULL, NULL, },
1360
};
1361

    
1362
/*******************************************************************/
1363

    
1364
static const char *pch;
1365
static jmp_buf expr_env;
1366

    
1367
#define MD_TLONG 0
1368
#define MD_I32   1
1369

    
1370
typedef struct MonitorDef {
1371
    const char *name;
1372
    int offset;
1373
    target_long (*get_value)(struct MonitorDef *md, int val);
1374
    int type;
1375
} MonitorDef;
1376

    
1377
#if defined(TARGET_I386)
1378
static target_long monitor_get_pc (struct MonitorDef *md, int val)
1379
{
1380
    CPUState *env = mon_get_cpu();
1381
    if (!env)
1382
        return 0;
1383
    return env->eip + env->segs[R_CS].base;
1384
}
1385
#endif
1386

    
1387
#if defined(TARGET_PPC)
1388
static target_long monitor_get_ccr (struct MonitorDef *md, int val)
1389
{
1390
    CPUState *env = mon_get_cpu();
1391
    unsigned int u;
1392
    int i;
1393

    
1394
    if (!env)
1395
        return 0;
1396

    
1397
    u = 0;
1398
    for (i = 0; i < 8; i++)
1399
        u |= env->crf[i] << (32 - (4 * i));
1400

    
1401
    return u;
1402
}
1403

    
1404
static target_long monitor_get_msr (struct MonitorDef *md, int val)
1405
{
1406
    CPUState *env = mon_get_cpu();
1407
    if (!env)
1408
        return 0;
1409
    return (env->msr[MSR_POW] << MSR_POW) |
1410
        (env->msr[MSR_ILE] << MSR_ILE) |
1411
        (env->msr[MSR_EE] << MSR_EE) |
1412
        (env->msr[MSR_PR] << MSR_PR) |
1413
        (env->msr[MSR_FP] << MSR_FP) |
1414
        (env->msr[MSR_ME] << MSR_ME) |
1415
        (env->msr[MSR_FE0] << MSR_FE0) |
1416
        (env->msr[MSR_SE] << MSR_SE) |
1417
        (env->msr[MSR_BE] << MSR_BE) |
1418
        (env->msr[MSR_FE1] << MSR_FE1) |
1419
        (env->msr[MSR_IP] << MSR_IP) |
1420
        (env->msr[MSR_IR] << MSR_IR) |
1421
        (env->msr[MSR_DR] << MSR_DR) |
1422
        (env->msr[MSR_RI] << MSR_RI) |
1423
        (env->msr[MSR_LE] << MSR_LE);
1424
}
1425

    
1426
static target_long monitor_get_xer (struct MonitorDef *md, int val)
1427
{
1428
    CPUState *env = mon_get_cpu();
1429
    if (!env)
1430
        return 0;
1431
    return (env->xer[XER_SO] << XER_SO) |
1432
        (env->xer[XER_OV] << XER_OV) |
1433
        (env->xer[XER_CA] << XER_CA) |
1434
        (env->xer[XER_BC] << XER_BC);
1435
}
1436

    
1437
static target_long monitor_get_decr (struct MonitorDef *md, int val)
1438
{
1439
    CPUState *env = mon_get_cpu();
1440
    if (!env)
1441
        return 0;
1442
    return cpu_ppc_load_decr(env);
1443
}
1444

    
1445
static target_long monitor_get_tbu (struct MonitorDef *md, int val)
1446
{
1447
    CPUState *env = mon_get_cpu();
1448
    if (!env)
1449
        return 0;
1450
    return cpu_ppc_load_tbu(env);
1451
}
1452

    
1453
static target_long monitor_get_tbl (struct MonitorDef *md, int val)
1454
{
1455
    CPUState *env = mon_get_cpu();
1456
    if (!env)
1457
        return 0;
1458
    return cpu_ppc_load_tbl(env);
1459
}
1460
#endif
1461

    
1462
#if defined(TARGET_SPARC)
1463
#ifndef TARGET_SPARC64
1464
static target_long monitor_get_psr (struct MonitorDef *md, int val)
1465
{
1466
    CPUState *env = mon_get_cpu();
1467
    if (!env)
1468
        return 0;
1469
    return GET_PSR(env);
1470
}
1471
#endif
1472

    
1473
static target_long monitor_get_reg(struct MonitorDef *md, int val)
1474
{
1475
    CPUState *env = mon_get_cpu();
1476
    if (!env)
1477
        return 0;
1478
    return env->regwptr[val];
1479
}
1480
#endif
1481

    
1482
static MonitorDef monitor_defs[] = {
1483
#ifdef TARGET_I386
1484

    
1485
#define SEG(name, seg) \
1486
    { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
1487
    { name ".base", offsetof(CPUState, segs[seg].base) },\
1488
    { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
1489

    
1490
    { "eax", offsetof(CPUState, regs[0]) },
1491
    { "ecx", offsetof(CPUState, regs[1]) },
1492
    { "edx", offsetof(CPUState, regs[2]) },
1493
    { "ebx", offsetof(CPUState, regs[3]) },
1494
    { "esp|sp", offsetof(CPUState, regs[4]) },
1495
    { "ebp|fp", offsetof(CPUState, regs[5]) },
1496
    { "esi", offsetof(CPUState, regs[6]) },
1497
    { "edi", offsetof(CPUState, regs[7]) },
1498
#ifdef TARGET_X86_64
1499
    { "r8", offsetof(CPUState, regs[8]) },
1500
    { "r9", offsetof(CPUState, regs[9]) },
1501
    { "r10", offsetof(CPUState, regs[10]) },
1502
    { "r11", offsetof(CPUState, regs[11]) },
1503
    { "r12", offsetof(CPUState, regs[12]) },
1504
    { "r13", offsetof(CPUState, regs[13]) },
1505
    { "r14", offsetof(CPUState, regs[14]) },
1506
    { "r15", offsetof(CPUState, regs[15]) },
1507
#endif
1508
    { "eflags", offsetof(CPUState, eflags) },
1509
    { "eip", offsetof(CPUState, eip) },
1510
    SEG("cs", R_CS)
1511
    SEG("ds", R_DS)
1512
    SEG("es", R_ES)
1513
    SEG("ss", R_SS)
1514
    SEG("fs", R_FS)
1515
    SEG("gs", R_GS)
1516
    { "pc", 0, monitor_get_pc, },
1517
#elif defined(TARGET_PPC)
1518
    { "r0", offsetof(CPUState, gpr[0]) },
1519
    { "r1", offsetof(CPUState, gpr[1]) },
1520
    { "r2", offsetof(CPUState, gpr[2]) },
1521
    { "r3", offsetof(CPUState, gpr[3]) },
1522
    { "r4", offsetof(CPUState, gpr[4]) },
1523
    { "r5", offsetof(CPUState, gpr[5]) },
1524
    { "r6", offsetof(CPUState, gpr[6]) },
1525
    { "r7", offsetof(CPUState, gpr[7]) },
1526
    { "r8", offsetof(CPUState, gpr[8]) },
1527
    { "r9", offsetof(CPUState, gpr[9]) },
1528
    { "r10", offsetof(CPUState, gpr[10]) },
1529
    { "r11", offsetof(CPUState, gpr[11]) },
1530
    { "r12", offsetof(CPUState, gpr[12]) },
1531
    { "r13", offsetof(CPUState, gpr[13]) },
1532
    { "r14", offsetof(CPUState, gpr[14]) },
1533
    { "r15", offsetof(CPUState, gpr[15]) },
1534
    { "r16", offsetof(CPUState, gpr[16]) },
1535
    { "r17", offsetof(CPUState, gpr[17]) },
1536
    { "r18", offsetof(CPUState, gpr[18]) },
1537
    { "r19", offsetof(CPUState, gpr[19]) },
1538
    { "r20", offsetof(CPUState, gpr[20]) },
1539
    { "r21", offsetof(CPUState, gpr[21]) },
1540
    { "r22", offsetof(CPUState, gpr[22]) },
1541
    { "r23", offsetof(CPUState, gpr[23]) },
1542
    { "r24", offsetof(CPUState, gpr[24]) },
1543
    { "r25", offsetof(CPUState, gpr[25]) },
1544
    { "r26", offsetof(CPUState, gpr[26]) },
1545
    { "r27", offsetof(CPUState, gpr[27]) },
1546
    { "r28", offsetof(CPUState, gpr[28]) },
1547
    { "r29", offsetof(CPUState, gpr[29]) },
1548
    { "r30", offsetof(CPUState, gpr[30]) },
1549
    { "r31", offsetof(CPUState, gpr[31]) },
1550
    { "nip|pc", offsetof(CPUState, nip) },
1551
    { "lr", offsetof(CPUState, lr) },
1552
    { "ctr", offsetof(CPUState, ctr) },
1553
    { "decr", 0, &monitor_get_decr, },
1554
    { "ccr", 0, &monitor_get_ccr, },
1555
    { "msr", 0, &monitor_get_msr, },
1556
    { "xer", 0, &monitor_get_xer, },
1557
    { "tbu", 0, &monitor_get_tbu, },
1558
    { "tbl", 0, &monitor_get_tbl, },
1559
    { "sdr1", offsetof(CPUState, sdr1) },
1560
    { "sr0", offsetof(CPUState, sr[0]) },
1561
    { "sr1", offsetof(CPUState, sr[1]) },
1562
    { "sr2", offsetof(CPUState, sr[2]) },
1563
    { "sr3", offsetof(CPUState, sr[3]) },
1564
    { "sr4", offsetof(CPUState, sr[4]) },
1565
    { "sr5", offsetof(CPUState, sr[5]) },
1566
    { "sr6", offsetof(CPUState, sr[6]) },
1567
    { "sr7", offsetof(CPUState, sr[7]) },
1568
    { "sr8", offsetof(CPUState, sr[8]) },
1569
    { "sr9", offsetof(CPUState, sr[9]) },
1570
    { "sr10", offsetof(CPUState, sr[10]) },
1571
    { "sr11", offsetof(CPUState, sr[11]) },
1572
    { "sr12", offsetof(CPUState, sr[12]) },
1573
    { "sr13", offsetof(CPUState, sr[13]) },
1574
    { "sr14", offsetof(CPUState, sr[14]) },
1575
    { "sr15", offsetof(CPUState, sr[15]) },
1576
    /* Too lazy to put BATs and SPRs ... */
1577
#elif defined(TARGET_SPARC)
1578
    { "g0", offsetof(CPUState, gregs[0]) },
1579
    { "g1", offsetof(CPUState, gregs[1]) },
1580
    { "g2", offsetof(CPUState, gregs[2]) },
1581
    { "g3", offsetof(CPUState, gregs[3]) },
1582
    { "g4", offsetof(CPUState, gregs[4]) },
1583
    { "g5", offsetof(CPUState, gregs[5]) },
1584
    { "g6", offsetof(CPUState, gregs[6]) },
1585
    { "g7", offsetof(CPUState, gregs[7]) },
1586
    { "o0", 0, monitor_get_reg },
1587
    { "o1", 1, monitor_get_reg },
1588
    { "o2", 2, monitor_get_reg },
1589
    { "o3", 3, monitor_get_reg },
1590
    { "o4", 4, monitor_get_reg },
1591
    { "o5", 5, monitor_get_reg },
1592
    { "o6", 6, monitor_get_reg },
1593
    { "o7", 7, monitor_get_reg },
1594
    { "l0", 8, monitor_get_reg },
1595
    { "l1", 9, monitor_get_reg },
1596
    { "l2", 10, monitor_get_reg },
1597
    { "l3", 11, monitor_get_reg },
1598
    { "l4", 12, monitor_get_reg },
1599
    { "l5", 13, monitor_get_reg },
1600
    { "l6", 14, monitor_get_reg },
1601
    { "l7", 15, monitor_get_reg },
1602
    { "i0", 16, monitor_get_reg },
1603
    { "i1", 17, monitor_get_reg },
1604
    { "i2", 18, monitor_get_reg },
1605
    { "i3", 19, monitor_get_reg },
1606
    { "i4", 20, monitor_get_reg },
1607
    { "i5", 21, monitor_get_reg },
1608
    { "i6", 22, monitor_get_reg },
1609
    { "i7", 23, monitor_get_reg },
1610
    { "pc", offsetof(CPUState, pc) },
1611
    { "npc", offsetof(CPUState, npc) },
1612
    { "y", offsetof(CPUState, y) },
1613
#ifndef TARGET_SPARC64
1614
    { "psr", 0, &monitor_get_psr, },
1615
    { "wim", offsetof(CPUState, wim) },
1616
#endif
1617
    { "tbr", offsetof(CPUState, tbr) },
1618
    { "fsr", offsetof(CPUState, fsr) },
1619
    { "f0", offsetof(CPUState, fpr[0]) },
1620
    { "f1", offsetof(CPUState, fpr[1]) },
1621
    { "f2", offsetof(CPUState, fpr[2]) },
1622
    { "f3", offsetof(CPUState, fpr[3]) },
1623
    { "f4", offsetof(CPUState, fpr[4]) },
1624
    { "f5", offsetof(CPUState, fpr[5]) },
1625
    { "f6", offsetof(CPUState, fpr[6]) },
1626
    { "f7", offsetof(CPUState, fpr[7]) },
1627
    { "f8", offsetof(CPUState, fpr[8]) },
1628
    { "f9", offsetof(CPUState, fpr[9]) },
1629
    { "f10", offsetof(CPUState, fpr[10]) },
1630
    { "f11", offsetof(CPUState, fpr[11]) },
1631
    { "f12", offsetof(CPUState, fpr[12]) },
1632
    { "f13", offsetof(CPUState, fpr[13]) },
1633
    { "f14", offsetof(CPUState, fpr[14]) },
1634
    { "f15", offsetof(CPUState, fpr[15]) },
1635
    { "f16", offsetof(CPUState, fpr[16]) },
1636
    { "f17", offsetof(CPUState, fpr[17]) },
1637
    { "f18", offsetof(CPUState, fpr[18]) },
1638
    { "f19", offsetof(CPUState, fpr[19]) },
1639
    { "f20", offsetof(CPUState, fpr[20]) },
1640
    { "f21", offsetof(CPUState, fpr[21]) },
1641
    { "f22", offsetof(CPUState, fpr[22]) },
1642
    { "f23", offsetof(CPUState, fpr[23]) },
1643
    { "f24", offsetof(CPUState, fpr[24]) },
1644
    { "f25", offsetof(CPUState, fpr[25]) },
1645
    { "f26", offsetof(CPUState, fpr[26]) },
1646
    { "f27", offsetof(CPUState, fpr[27]) },
1647
    { "f28", offsetof(CPUState, fpr[28]) },
1648
    { "f29", offsetof(CPUState, fpr[29]) },
1649
    { "f30", offsetof(CPUState, fpr[30]) },
1650
    { "f31", offsetof(CPUState, fpr[31]) },
1651
#ifdef TARGET_SPARC64
1652
    { "f32", offsetof(CPUState, fpr[32]) },
1653
    { "f34", offsetof(CPUState, fpr[34]) },
1654
    { "f36", offsetof(CPUState, fpr[36]) },
1655
    { "f38", offsetof(CPUState, fpr[38]) },
1656
    { "f40", offsetof(CPUState, fpr[40]) },
1657
    { "f42", offsetof(CPUState, fpr[42]) },
1658
    { "f44", offsetof(CPUState, fpr[44]) },
1659
    { "f46", offsetof(CPUState, fpr[46]) },
1660
    { "f48", offsetof(CPUState, fpr[48]) },
1661
    { "f50", offsetof(CPUState, fpr[50]) },
1662
    { "f52", offsetof(CPUState, fpr[52]) },
1663
    { "f54", offsetof(CPUState, fpr[54]) },
1664
    { "f56", offsetof(CPUState, fpr[56]) },
1665
    { "f58", offsetof(CPUState, fpr[58]) },
1666
    { "f60", offsetof(CPUState, fpr[60]) },
1667
    { "f62", offsetof(CPUState, fpr[62]) },
1668
    { "asi", offsetof(CPUState, asi) },
1669
    { "pstate", offsetof(CPUState, pstate) },
1670
    { "cansave", offsetof(CPUState, cansave) },
1671
    { "canrestore", offsetof(CPUState, canrestore) },
1672
    { "otherwin", offsetof(CPUState, otherwin) },
1673
    { "wstate", offsetof(CPUState, wstate) },
1674
    { "cleanwin", offsetof(CPUState, cleanwin) },
1675
    { "fprs", offsetof(CPUState, fprs) },
1676
#endif
1677
#endif
1678
    { NULL },
1679
};
1680

    
1681
static void expr_error(const char *fmt)
1682
{
1683
    term_printf(fmt);
1684
    term_printf("\n");
1685
    longjmp(expr_env, 1);
1686
}
1687

    
1688
/* return 0 if OK, -1 if not found, -2 if no CPU defined */
1689
static int get_monitor_def(target_long *pval, const char *name)
1690
{
1691
    MonitorDef *md;
1692
    void *ptr;
1693

    
1694
    for(md = monitor_defs; md->name != NULL; md++) {
1695
        if (compare_cmd(name, md->name)) {
1696
            if (md->get_value) {
1697
                *pval = md->get_value(md, md->offset);
1698
            } else {
1699
                CPUState *env = mon_get_cpu();
1700
                if (!env)
1701
                    return -2;
1702
                ptr = (uint8_t *)env + md->offset;
1703
                switch(md->type) {
1704
                case MD_I32:
1705
                    *pval = *(int32_t *)ptr;
1706
                    break;
1707
                case MD_TLONG:
1708
                    *pval = *(target_long *)ptr;
1709
                    break;
1710
                default:
1711
                    *pval = 0;
1712
                    break;
1713
                }
1714
            }
1715
            return 0;
1716
        }
1717
    }
1718
    return -1;
1719
}
1720

    
1721
static void next(void)
1722
{
1723
    if (pch != '\0') {
1724
        pch++;
1725
        while (isspace(*pch))
1726
            pch++;
1727
    }
1728
}
1729

    
1730
static target_long expr_sum(void);
1731

    
1732
static target_long expr_unary(void)
1733
{
1734
    target_long n;
1735
    char *p;
1736
    int ret;
1737

    
1738
    switch(*pch) {
1739
    case '+':
1740
        next();
1741
        n = expr_unary();
1742
        break;
1743
    case '-':
1744
        next();
1745
        n = -expr_unary();
1746
        break;
1747
    case '~':
1748
        next();
1749
        n = ~expr_unary();
1750
        break;
1751
    case '(':
1752
        next();
1753
        n = expr_sum();
1754
        if (*pch != ')') {
1755
            expr_error("')' expected");
1756
        }
1757
        next();
1758
        break;
1759
    case '\'':
1760
        pch++;
1761
        if (*pch == '\0')
1762
            expr_error("character constant expected");
1763
        n = *pch;
1764
        pch++;
1765
        if (*pch != '\'')
1766
            expr_error("missing terminating \' character");
1767
        next();
1768
        break;
1769
    case '$':
1770
        {
1771
            char buf[128], *q;
1772
           
1773
            pch++;
1774
            q = buf;
1775
            while ((*pch >= 'a' && *pch <= 'z') ||
1776
                   (*pch >= 'A' && *pch <= 'Z') ||
1777
                   (*pch >= '0' && *pch <= '9') ||
1778
                   *pch == '_' || *pch == '.') {
1779
                if ((q - buf) < sizeof(buf) - 1)
1780
                    *q++ = *pch;
1781
                pch++;
1782
            }
1783
            while (isspace(*pch))
1784
                pch++;
1785
            *q = 0;
1786
            ret = get_monitor_def(&n, buf);
1787
            if (ret == -1)
1788
                expr_error("unknown register");
1789
            else if (ret == -2)
1790
                expr_error("no cpu defined");
1791
        }
1792
        break;
1793
    case '\0':
1794
        expr_error("unexpected end of expression");
1795
        n = 0;
1796
        break;
1797
    default:
1798
#if TARGET_LONG_BITS == 64
1799
        n = strtoull(pch, &p, 0);
1800
#else
1801
        n = strtoul(pch, &p, 0);
1802
#endif
1803
        if (pch == p) {
1804
            expr_error("invalid char in expression");
1805
        }
1806
        pch = p;
1807
        while (isspace(*pch))
1808
            pch++;
1809
        break;
1810
    }
1811
    return n;
1812
}
1813

    
1814

    
1815
static target_long expr_prod(void)
1816
{
1817
    target_long val, val2;
1818
    int op;
1819
   
1820
    val = expr_unary();
1821
    for(;;) {
1822
        op = *pch;
1823
        if (op != '*' && op != '/' && op != '%')
1824
            break;
1825
        next();
1826
        val2 = expr_unary();
1827
        switch(op) {
1828
        default:
1829
        case '*':
1830
            val *= val2;
1831
            break;
1832
        case '/':
1833
        case '%':
1834
            if (val2 == 0)
1835
                expr_error("division by zero");
1836
            if (op == '/')
1837
                val /= val2;
1838
            else
1839
                val %= val2;
1840
            break;
1841
        }
1842
    }
1843
    return val;
1844
}
1845

    
1846
static target_long expr_logic(void)
1847
{
1848
    target_long val, val2;
1849
    int op;
1850

    
1851
    val = expr_prod();
1852
    for(;;) {
1853
        op = *pch;
1854
        if (op != '&' && op != '|' && op != '^')
1855
            break;
1856
        next();
1857
        val2 = expr_prod();
1858
        switch(op) {
1859
        default:
1860
        case '&':
1861
            val &= val2;
1862
            break;
1863
        case '|':
1864
            val |= val2;
1865
            break;
1866
        case '^':
1867
            val ^= val2;
1868
            break;
1869
        }
1870
    }
1871
    return val;
1872
}
1873

    
1874
static target_long expr_sum(void)
1875
{
1876
    target_long val, val2;
1877
    int op;
1878

    
1879
    val = expr_logic();
1880
    for(;;) {
1881
        op = *pch;
1882
        if (op != '+' && op != '-')
1883
            break;
1884
        next();
1885
        val2 = expr_logic();
1886
        if (op == '+')
1887
            val += val2;
1888
        else
1889
            val -= val2;
1890
    }
1891
    return val;
1892
}
1893

    
1894
static int get_expr(target_long *pval, const char **pp)
1895
{
1896
    pch = *pp;
1897
    if (setjmp(expr_env)) {
1898
        *pp = pch;
1899
        return -1;
1900
    }
1901
    while (isspace(*pch))
1902
        pch++;
1903
    *pval = expr_sum();
1904
    *pp = pch;
1905
    return 0;
1906
}
1907

    
1908
static int get_str(char *buf, int buf_size, const char **pp)
1909
{
1910
    const char *p;
1911
    char *q;
1912
    int c;
1913

    
1914
    q = buf;
1915
    p = *pp;
1916
    while (isspace(*p))
1917
        p++;
1918
    if (*p == '\0') {
1919
    fail:
1920
        *q = '\0';
1921
        *pp = p;
1922
        return -1;
1923
    }
1924
    if (*p == '\"') {
1925
        p++;
1926
        while (*p != '\0' && *p != '\"') {
1927
            if (*p == '\\') {
1928
                p++;
1929
                c = *p++;
1930
                switch(c) {
1931
                case 'n':
1932
                    c = '\n';
1933
                    break;
1934
                case 'r':
1935
                    c = '\r';
1936
                    break;
1937
                case '\\':
1938
                case '\'':
1939
                case '\"':
1940
                    break;
1941
                default:
1942
                    qemu_printf("unsupported escape code: '\\%c'\n", c);
1943
                    goto fail;
1944
                }
1945
                if ((q - buf) < buf_size - 1) {
1946
                    *q++ = c;
1947
                }
1948
            } else {
1949
                if ((q - buf) < buf_size - 1) {
1950
                    *q++ = *p;
1951
                }
1952
                p++;
1953
            }
1954
        }
1955
        if (*p != '\"') {
1956
            qemu_printf("unterminated string\n");
1957
            goto fail;
1958
        }
1959
        p++;
1960
    } else {
1961
        while (*p != '\0' && !isspace(*p)) {
1962
            if ((q - buf) < buf_size - 1) {
1963
                *q++ = *p;
1964
            }
1965
            p++;
1966
        }
1967
    }
1968
    *q = '\0';
1969
    *pp = p;
1970
    return 0;
1971
}
1972

    
1973
static int default_fmt_format = 'x';
1974
static int default_fmt_size = 4;
1975

    
1976
#define MAX_ARGS 16
1977

    
1978
static void monitor_handle_command(const char *cmdline)
1979
{
1980
    const char *p, *pstart, *typestr;
1981
    char *q;
1982
    int c, nb_args, len, i, has_arg;
1983
    term_cmd_t *cmd;
1984
    char cmdname[256];
1985
    char buf[1024];
1986
    void *str_allocated[MAX_ARGS];
1987
    void *args[MAX_ARGS];
1988

    
1989
#ifdef DEBUG
1990
    term_printf("command='%s'\n", cmdline);
1991
#endif
1992
   
1993
    /* extract the command name */
1994
    p = cmdline;
1995
    q = cmdname;
1996
    while (isspace(*p))
1997
        p++;
1998
    if (*p == '\0')
1999
        return;
2000
    pstart = p;
2001
    while (*p != '\0' && *p != '/' && !isspace(*p))
2002
        p++;
2003
    len = p - pstart;
2004
    if (len > sizeof(cmdname) - 1)
2005
        len = sizeof(cmdname) - 1;
2006
    memcpy(cmdname, pstart, len);
2007
    cmdname[len] = '\0';
2008
   
2009
    /* find the command */
2010
    for(cmd = term_cmds; cmd->name != NULL; cmd++) {
2011
        if (compare_cmd(cmdname, cmd->name))
2012
            goto found;
2013
    }
2014
    term_printf("unknown command: '%s'\n", cmdname);
2015
    return;
2016
 found:
2017

    
2018
    for(i = 0; i < MAX_ARGS; i++)
2019
        str_allocated[i] = NULL;
2020
   
2021
    /* parse the parameters */
2022
    typestr = cmd->args_type;
2023
    nb_args = 0;
2024
    for(;;) {
2025
        c = *typestr;
2026
        if (c == '\0')
2027
            break;
2028
        typestr++;
2029
        switch(c) {
2030
        case 'F':
2031
        case 'B':
2032
        case 's':
2033
            {
2034
                int ret;
2035
                char *str;
2036
               
2037
                while (isspace(*p))
2038
                    p++;
2039
                if (*typestr == '?') {
2040
                    typestr++;
2041
                    if (*p == '\0') {
2042
                        /* no optional string: NULL argument */
2043
                        str = NULL;
2044
                        goto add_str;
2045
                    }
2046
                }
2047
                ret = get_str(buf, sizeof(buf), &p);
2048
                if (ret < 0) {
2049
                    switch(c) {
2050
                    case 'F':
2051
                        term_printf("%s: filename expected\n", cmdname);
2052
                        break;
2053
                    case 'B':
2054
                        term_printf("%s: block device name expected\n", cmdname);
2055
                        break;
2056
                    default:
2057
                        term_printf("%s: string expected\n", cmdname);
2058
                        break;
2059
                    }
2060
                    goto fail;
2061
                }
2062
                str = qemu_malloc(strlen(buf) + 1);
2063
                strcpy(str, buf);
2064
                str_allocated[nb_args] = str;
2065
            add_str:
2066
                if (nb_args >= MAX_ARGS) {
2067
                error_args:
2068
                    term_printf("%s: too many arguments\n", cmdname);
2069
                    goto fail;
2070
                }
2071
                args[nb_args++] = str;
2072
            }
2073
            break;
2074
        case '/':
2075
            {
2076
                int count, format, size;
2077
               
2078
                while (isspace(*p))
2079
                    p++;
2080
                if (*p == '/') {
2081
                    /* format found */
2082
                    p++;
2083
                    count = 1;
2084
                    if (isdigit(*p)) {
2085
                        count = 0;
2086
                        while (isdigit(*p)) {
2087
                            count = count * 10 + (*p - '0');
2088
                            p++;
2089
                        }
2090
                    }
2091
                    size = -1;
2092
                    format = -1;
2093
                    for(;;) {
2094
                        switch(*p) {
2095
                        case 'o':
2096
                        case 'd':
2097
                        case 'u':
2098
                        case 'x':
2099
                        case 'i':
2100
                        case 'c':
2101
                            format = *p++;
2102
                            break;
2103
                        case 'b':
2104
                            size = 1;
2105
                            p++;
2106
                            break;
2107
                        case 'h':
2108
                            size = 2;
2109
                            p++;
2110
                            break;
2111
                        case 'w':
2112
                            size = 4;
2113
                            p++;
2114
                            break;
2115
                        case 'g':
2116
                        case 'L':
2117
                            size = 8;
2118
                            p++;
2119
                            break;
2120
                        default:
2121
                            goto next;
2122
                        }
2123
                    }
2124
                next:
2125
                    if (*p != '\0' && !isspace(*p)) {
2126
                        term_printf("invalid char in format: '%c'\n", *p);
2127
                        goto fail;
2128
                    }
2129
                    if (format < 0)
2130
                        format = default_fmt_format;
2131
                    if (format != 'i') {
2132
                        /* for 'i', not specifying a size gives -1 as size */
2133
                        if (size < 0)
2134
                            size = default_fmt_size;
2135
                    }
2136
                    default_fmt_size = size;
2137
                    default_fmt_format = format;
2138
                } else {
2139
                    count = 1;
2140
                    format = default_fmt_format;
2141
                    if (format != 'i') {
2142
                        size = default_fmt_size;
2143
                    } else {
2144
                        size = -1;
2145
                    }
2146
                }
2147
                if (nb_args + 3 > MAX_ARGS)
2148
                    goto error_args;
2149
                args[nb_args++] = (void*)(long)count;
2150
                args[nb_args++] = (void*)(long)format;
2151
                args[nb_args++] = (void*)(long)size;
2152
            }
2153
            break;
2154
        case 'i':
2155
        case 'l':
2156
            {
2157
                target_long val;
2158
                while (isspace(*p))
2159
                    p++;
2160
                if (*typestr == '?' || *typestr == '.') {
2161
                    if (*typestr == '?') {
2162
                        if (*p == '\0')
2163
                            has_arg = 0;
2164
                        else
2165
                            has_arg = 1;
2166
                    } else {
2167
                        if (*p == '.') {
2168
                            p++;
2169
                            while (isspace(*p))
2170
                                p++;
2171
                            has_arg = 1;
2172
                        } else {
2173
                            has_arg = 0;
2174
                        }
2175
                    }
2176
                    typestr++;
2177
                    if (nb_args >= MAX_ARGS)
2178
                        goto error_args;
2179
                    args[nb_args++] = (void *)(long)has_arg;
2180
                    if (!has_arg) {
2181
                        if (nb_args >= MAX_ARGS)
2182
                            goto error_args;
2183
                        val = -1;
2184
                        goto add_num;
2185
                    }
2186
                }
2187
                if (get_expr(&val, &p))
2188
                    goto fail;
2189
            add_num:
2190
                if (c == 'i') {
2191
                    if (nb_args >= MAX_ARGS)
2192
                        goto error_args;
2193
                    args[nb_args++] = (void *)(long)val;
2194
                } else {
2195
                    if ((nb_args + 1) >= MAX_ARGS)
2196
                        goto error_args;
2197
#if TARGET_LONG_BITS == 64
2198
                    args[nb_args++] = (void *)(long)((val >> 32) & 0xffffffff);
2199
#else
2200
                    args[nb_args++] = (void *)0;
2201
#endif
2202
                    args[nb_args++] = (void *)(long)(val & 0xffffffff);
2203
                }
2204
            }
2205
            break;
2206
        case '-':
2207
            {
2208
                int has_option;
2209
                /* option */
2210
               
2211
                c = *typestr++;
2212
                if (c == '\0')
2213
                    goto bad_type;
2214
                while (isspace(*p))
2215
                    p++;
2216
                has_option = 0;
2217
                if (*p == '-') {
2218
                    p++;
2219
                    if (*p != c) {
2220
                        term_printf("%s: unsupported option -%c\n",
2221
                                    cmdname, *p);
2222
                        goto fail;
2223
                    }
2224
                    p++;
2225
                    has_option = 1;
2226
                }
2227
                if (nb_args >= MAX_ARGS)
2228
                    goto error_args;
2229
                args[nb_args++] = (void *)(long)has_option;
2230
            }
2231
            break;
2232
        default:
2233
        bad_type:
2234
            term_printf("%s: unknown type '%c'\n", cmdname, c);
2235
            goto fail;
2236
        }
2237
    }
2238
    /* check that all arguments were parsed */
2239
    while (isspace(*p))
2240
        p++;
2241
    if (*p != '\0') {
2242
        term_printf("%s: extraneous characters at the end of line\n",
2243
                    cmdname);
2244
        goto fail;
2245
    }
2246

    
2247
    switch(nb_args) {
2248
    case 0:
2249
        cmd->handler();
2250
        break;
2251
    case 1:
2252
        cmd->handler(args[0]);
2253
        break;
2254
    case 2:
2255
        cmd->handler(args[0], args[1]);
2256
        break;
2257
    case 3:
2258
        cmd->handler(args[0], args[1], args[2]);
2259
        break;
2260
    case 4:
2261
        cmd->handler(args[0], args[1], args[2], args[3]);
2262
        break;
2263
    case 5:
2264
        cmd->handler(args[0], args[1], args[2], args[3], args[4]);
2265
        break;
2266
    case 6:
2267
        cmd->handler(args[0], args[1], args[2], args[3], args[4], args[5]);
2268
        break;
2269
    case 7:
2270
        cmd->handler(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
2271
        break;
2272
    default:
2273
        term_printf("unsupported number of arguments: %d\n", nb_args);
2274
        goto fail;
2275
    }
2276
 fail:
2277
    for(i = 0; i < MAX_ARGS; i++)
2278
        qemu_free(str_allocated[i]);
2279
    return;
2280
}
2281

    
2282
static void cmd_completion(const char *name, const char *list)
2283
{
2284
    const char *p, *pstart;
2285
    char cmd[128];
2286
    int len;
2287

    
2288
    p = list;
2289
    for(;;) {
2290
        pstart = p;
2291
        p = strchr(p, '|');
2292
        if (!p)
2293
            p = pstart + strlen(pstart);
2294
        len = p - pstart;
2295
        if (len > sizeof(cmd) - 2)
2296
            len = sizeof(cmd) - 2;
2297
        memcpy(cmd, pstart, len);
2298
        cmd[len] = '\0';
2299
        if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
2300
            add_completion(cmd);
2301
        }
2302
        if (*p == '\0')
2303
            break;
2304
        p++;
2305
    }
2306
}
2307

    
2308
static void file_completion(const char *input)
2309
{
2310
    DIR *ffs;
2311
    struct dirent *d;
2312
    char path[1024];
2313
    char file[1024], file_prefix[1024];
2314
    int input_path_len;
2315
    const char *p;
2316

    
2317
    p = strrchr(input, '/');
2318
    if (!p) {
2319
        input_path_len = 0;
2320
        pstrcpy(file_prefix, sizeof(file_prefix), input);
2321
        strcpy(path, ".");
2322
    } else {
2323
        input_path_len = p - input + 1;
2324
        memcpy(path, input, input_path_len);
2325
        if (input_path_len > sizeof(path) - 1)
2326
            input_path_len = sizeof(path) - 1;
2327
        path[input_path_len] = '\0';
2328
        pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
2329
    }
2330
#ifdef DEBUG_COMPLETION
2331
    term_printf("input='%s' path='%s' prefix='%s'\n", input, path, file_prefix);
2332
#endif
2333
    ffs = opendir(path);
2334
    if (!ffs)
2335
        return;
2336
    for(;;) {
2337
        struct stat sb;
2338
        d = readdir(ffs);
2339
        if (!d)
2340
            break;
2341
        if (strstart(d->d_name, file_prefix, NULL)) {
2342
            memcpy(file, input, input_path_len);
2343
            strcpy(file + input_path_len, d->d_name);
2344
            /* stat the file to find out if it's a directory.
2345
             * In that case add a slash to speed up typing long paths
2346
             */
2347
            stat(file, &sb);
2348
            if(S_ISDIR(sb.st_mode))
2349
                strcat(file, "/");
2350
            add_completion(file);
2351
        }
2352
    }
2353
    closedir(ffs);
2354
}
2355

    
2356
static void block_completion_it(void *opaque, const char *name)
2357
{
2358
    const char *input = opaque;
2359

    
2360
    if (input[0] == '\0' ||
2361
        !strncmp(name, (char *)input, strlen(input))) {
2362
        add_completion(name);
2363
    }
2364
}
2365

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

    
2374
    p = cmdline;
2375
    nb_args = 0;
2376
    for(;;) {
2377
        while (isspace(*p))
2378
            p++;
2379
        if (*p == '\0')
2380
            break;
2381
        if (nb_args >= MAX_ARGS)
2382
            break;
2383
        ret = get_str(buf, sizeof(buf), &p);
2384
        args[nb_args] = qemu_strdup(buf);
2385
        nb_args++;
2386
        if (ret < 0)
2387
            break;
2388
    }
2389
    *pnb_args = nb_args;
2390
}
2391

    
2392
void readline_find_completion(const char *cmdline)
2393
{
2394
    const char *cmdname;
2395
    char *args[MAX_ARGS];
2396
    int nb_args, i, len;
2397
    const char *ptype, *str;
2398
    term_cmd_t *cmd;
2399
    const KeyDef *key;
2400

    
2401
    parse_cmdline(cmdline, &nb_args, args);
2402
#ifdef DEBUG_COMPLETION
2403
    for(i = 0; i < nb_args; i++) {
2404
        term_printf("arg%d = '%s'\n", i, (char *)args[i]);
2405
    }
2406
#endif
2407

    
2408
    /* if the line ends with a space, it means we want to complete the
2409
       next arg */
2410
    len = strlen(cmdline);
2411
    if (len > 0 && isspace(cmdline[len - 1])) {
2412
        if (nb_args >= MAX_ARGS)
2413
            return;
2414
        args[nb_args++] = qemu_strdup("");
2415
    }
2416
    if (nb_args <= 1) {
2417
        /* command completion */
2418
        if (nb_args == 0)
2419
            cmdname = "";
2420
        else
2421
            cmdname = args[0];
2422
        completion_index = strlen(cmdname);
2423
        for(cmd = term_cmds; cmd->name != NULL; cmd++) {
2424
            cmd_completion(cmdname, cmd->name);
2425
        }
2426
    } else {
2427
        /* find the command */
2428
        for(cmd = term_cmds; cmd->name != NULL; cmd++) {
2429
            if (compare_cmd(args[0], cmd->name))
2430
                goto found;
2431
        }
2432
        return;
2433
    found:
2434
        ptype = cmd->args_type;
2435
        for(i = 0; i < nb_args - 2; i++) {
2436
            if (*ptype != '\0') {
2437
                ptype++;
2438
                while (*ptype == '?')
2439
                    ptype++;
2440
            }
2441
        }
2442
        str = args[nb_args - 1];
2443
        switch(*ptype) {
2444
        case 'F':
2445
            /* file completion */
2446
            completion_index = strlen(str);
2447
            file_completion(str);
2448
            break;
2449
        case 'B':
2450
            /* block device name completion */
2451
            completion_index = strlen(str);
2452
            bdrv_iterate(block_completion_it, (void *)str);
2453
            break;
2454
        case 's':
2455
            /* XXX: more generic ? */
2456
            if (!strcmp(cmd->name, "info")) {
2457
                completion_index = strlen(str);
2458
                for(cmd = info_cmds; cmd->name != NULL; cmd++) {
2459
                    cmd_completion(str, cmd->name);
2460
                }
2461
            } else if (!strcmp(cmd->name, "sendkey")) {
2462
                completion_index = strlen(str);
2463
                for(key = key_defs; key->name != NULL; key++) {
2464
                    cmd_completion(str, key->name);
2465
                }
2466
            }
2467
            break;
2468
        default:
2469
            break;
2470
        }
2471
    }
2472
    for(i = 0; i < nb_args; i++)
2473
        qemu_free(args[i]);
2474
}
2475

    
2476
static int term_can_read(void *opaque)
2477
{
2478
    return 128;
2479
}
2480

    
2481
static void term_read(void *opaque, const uint8_t *buf, int size)
2482
{
2483
    int i;
2484
    for(i = 0; i < size; i++)
2485
        readline_handle_byte(buf[i]);
2486
}
2487

    
2488
static void monitor_start_input(void);
2489

    
2490
static void monitor_handle_command1(void *opaque, const char *cmdline)
2491
{
2492
    monitor_handle_command(cmdline);
2493
    monitor_start_input();
2494
}
2495

    
2496
static void monitor_start_input(void)
2497
{
2498
    readline_start("(qemu) ", 0, monitor_handle_command1, NULL);
2499
}
2500

    
2501
static void term_event(void *opaque, int event)
2502
{
2503
    if (event != CHR_EVENT_RESET)
2504
        return;
2505

    
2506
    if (!hide_banner)
2507
            term_printf("QEMU %s monitor - type 'help' for more information\n",
2508
                        QEMU_VERSION);
2509
    monitor_start_input();
2510
}
2511

    
2512
static int is_first_init = 1;
2513

    
2514
void monitor_init(CharDriverState *hd, int show_banner)
2515
{
2516
    int i;
2517

    
2518
    if (is_first_init) {
2519
        for (i = 0; i < MAX_MON; i++) {
2520
            monitor_hd[i] = NULL;
2521
        }
2522
        is_first_init = 0;
2523
    }
2524
    for (i = 0; i < MAX_MON; i++) {
2525
        if (monitor_hd[i] == NULL) {
2526
            monitor_hd[i] = hd;
2527
            break;
2528
        }
2529
    }
2530

    
2531
    hide_banner = !show_banner;
2532

    
2533
    qemu_chr_add_handlers(hd, term_can_read, term_read, term_event, NULL);
2534
}
2535

    
2536
/* XXX: use threads ? */
2537
/* modal monitor readline */
2538
static int monitor_readline_started;
2539
static char *monitor_readline_buf;
2540
static int monitor_readline_buf_size;
2541

    
2542
static void monitor_readline_cb(void *opaque, const char *input)
2543
{
2544
    pstrcpy(monitor_readline_buf, monitor_readline_buf_size, input);
2545
    monitor_readline_started = 0;
2546
}
2547

    
2548
void monitor_readline(const char *prompt, int is_password,
2549
                      char *buf, int buf_size)
2550
{
2551
    int i;
2552

    
2553
    if (is_password) {
2554
        for (i = 0; i < MAX_MON; i++)
2555
            if (monitor_hd[i] && monitor_hd[i]->focus == 0)
2556
                qemu_chr_send_event(monitor_hd[i], CHR_EVENT_FOCUS);
2557
    }
2558
    readline_start(prompt, is_password, monitor_readline_cb, NULL);
2559
    monitor_readline_buf = buf;
2560
    monitor_readline_buf_size = buf_size;
2561
    monitor_readline_started = 1;
2562
    while (monitor_readline_started) {
2563
        main_loop_wait(10);
2564
    }
2565
}