Statistics
| Branch: | Revision:

root / monitor.c @ 26a76461

History | View | Annotate | Download (60 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
static CharDriverState *monitor_hd;
58

    
59
static term_cmd_t term_cmds[];
60
static term_cmd_t info_cmds[];
61

    
62
static char term_outbuf[1024];
63
static int term_outbuf_index;
64

    
65
static void monitor_start_input(void);
66

    
67
CPUState *mon_cpu = NULL;
68

    
69
void term_flush(void)
70
{
71
    if (term_outbuf_index > 0) {
72
        qemu_chr_write(monitor_hd, term_outbuf, term_outbuf_index);
73
        term_outbuf_index = 0;
74
    }
75
}
76

    
77
/* flush at every end of line or if the buffer is full */
78
void term_puts(const char *str)
79
{
80
    int c;
81
    for(;;) {
82
        c = *str++;
83
        if (c == '\0')
84
            break;
85
        term_outbuf[term_outbuf_index++] = c;
86
        if (term_outbuf_index >= sizeof(term_outbuf) ||
87
            c == '\n')
88
            term_flush();
89
    }
90
}
91

    
92
void term_vprintf(const char *fmt, va_list ap)
93
{
94
    char buf[4096];
95
    vsnprintf(buf, sizeof(buf), fmt, ap);
96
    term_puts(buf);
97
}
98

    
99
void term_printf(const char *fmt, ...)
100
{
101
    va_list ap;
102
    va_start(ap, fmt);
103
    term_vprintf(fmt, ap);
104
    va_end(ap);
105
}
106

    
107
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
108
{
109
    va_list ap;
110
    va_start(ap, fmt);
111
    term_vprintf(fmt, ap);
112
    va_end(ap);
113
    return 0;
114
}
115

    
116
static int compare_cmd(const char *name, const char *list)
117
{
118
    const char *p, *pstart;
119
    int len;
120
    len = strlen(name);
121
    p = list;
122
    for(;;) {
123
        pstart = p;
124
        p = strchr(p, '|');
125
        if (!p)
126
            p = pstart + strlen(pstart);
127
        if ((p - pstart) == len && !memcmp(pstart, name, len))
128
            return 1;
129
        if (*p == '\0')
130
            break;
131
        p++;
132
    }
133
    return 0;
134
}
135

    
136
static void help_cmd1(term_cmd_t *cmds, const char *prefix, const char *name)
137
{
138
    term_cmd_t *cmd;
139

    
140
    for(cmd = cmds; cmd->name != NULL; cmd++) {
141
        if (!name || !strcmp(name, cmd->name))
142
            term_printf("%s%s %s -- %s\n", prefix, cmd->name, cmd->params, cmd->help);
143
    }
144
}
145

    
146
static void help_cmd(const char *name)
147
{
148
    if (name && !strcmp(name, "info")) {
149
        help_cmd1(info_cmds, "info ", NULL);
150
    } else {
151
        help_cmd1(term_cmds, "", name);
152
        if (name && !strcmp(name, "log")) {
153
            CPULogItem *item;
154
            term_printf("Log items (comma separated):\n");
155
            term_printf("%-10s %s\n", "none", "remove all logs");
156
            for(item = cpu_log_items; item->mask != 0; item++) {
157
                term_printf("%-10s %s\n", item->name, item->help);
158
            }
159
        }
160
    }
161
}
162

    
163
static void do_help(const char *name)
164
{
165
    help_cmd(name);
166
}
167

    
168
static void do_commit(void)
169
{
170
    int i;
171

    
172
    for (i = 0; i < MAX_DISKS; i++) {
173
        if (bs_table[i]) {
174
            bdrv_commit(bs_table[i]);
175
        }
176
    }
177
}
178

    
179
static void do_info(const char *item)
180
{
181
    term_cmd_t *cmd;
182

    
183
    if (!item)
184
        goto help;
185
    for(cmd = info_cmds; cmd->name != NULL; cmd++) {
186
        if (compare_cmd(item, cmd->name)) 
187
            goto found;
188
    }
189
 help:
190
    help_cmd("info");
191
    return;
192
 found:
193
    cmd->handler();
194
}
195

    
196
static void do_info_version(void)
197
{
198
  term_printf("%s\n", QEMU_VERSION);
199
}
200

    
201
static void do_info_block(void)
202
{
203
    bdrv_info();
204
}
205

    
206
/* get the current CPU defined by the user */
207
int mon_set_cpu(int cpu_index)
208
{
209
    CPUState *env;
210

    
211
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
212
        if (env->cpu_index == cpu_index) {
213
            mon_cpu = env;
214
            return 0;
215
        }
216
    }
217
    return -1;
218
}
219

    
220
CPUState *mon_get_cpu(void)
221
{
222
    if (!mon_cpu) {
223
        mon_set_cpu(0);
224
    }
225
    return mon_cpu;
226
}
227

    
228
static void do_info_registers(void)
229
{
230
    CPUState *env;
231
    env = mon_get_cpu();
232
    if (!env)
233
        return;
234
#ifdef TARGET_I386
235
    cpu_dump_state(env, NULL, monitor_fprintf,
236
                   X86_DUMP_FPU);
237
#else
238
    cpu_dump_state(env, NULL, monitor_fprintf, 
239
                   0);
240
#endif
241
}
242

    
243
static void do_info_cpus(void)
244
{
245
    CPUState *env;
246

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

    
250
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
251
        term_printf("%c CPU #%d:", 
252
                    (env == mon_cpu) ? '*' : ' ',
253
                    env->cpu_index);
254
#if defined(TARGET_I386)
255
        term_printf(" pc=0x" TARGET_FMT_lx, env->eip + env->segs[R_CS].base);
256
        if (env->hflags & HF_HALTED_MASK)
257
            term_printf(" (halted)");
258
#elif defined(TARGET_PPC)
259
        term_printf(" nip=0x" TARGET_FMT_lx, env->nip);
260
        if (env->halted)
261
            term_printf(" (halted)");
262
#elif defined(TARGET_SPARC)
263
        term_printf(" pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx, env->pc, env->npc);
264
        if (env->halted)
265
            term_printf(" (halted)");
266
#endif
267
        term_printf("\n");
268
    }
269
}
270

    
271
static void do_cpu_set(int index)
272
{
273
    if (mon_set_cpu(index) < 0)
274
        term_printf("Invalid CPU index\n");
275
}
276

    
277
static void do_info_jit(void)
278
{
279
    dump_exec_info(NULL, monitor_fprintf);
280
}
281

    
282
static void do_info_history (void)
283
{
284
    int i;
285
    const char *str;
286
    
287
    i = 0;
288
    for(;;) {
289
        str = readline_get_history(i);
290
        if (!str)
291
            break;
292
        term_printf("%d: '%s'\n", i, str);
293
        i++;
294
    }
295
}
296

    
297
static void do_quit(void)
298
{
299
    exit(0);
300
}
301

    
302
static int eject_device(BlockDriverState *bs, int force)
303
{
304
    if (bdrv_is_inserted(bs)) {
305
        if (!force) {
306
            if (!bdrv_is_removable(bs)) {
307
                term_printf("device is not removable\n");
308
                return -1;
309
            }
310
            if (bdrv_is_locked(bs)) {
311
                term_printf("device is locked\n");
312
                return -1;
313
            }
314
        }
315
        bdrv_close(bs);
316
    }
317
    return 0;
318
}
319

    
320
static void do_eject(int force, const char *filename)
321
{
322
    BlockDriverState *bs;
323

    
324
    bs = bdrv_find(filename);
325
    if (!bs) {
326
        term_printf("device not found\n");
327
        return;
328
    }
329
    eject_device(bs, force);
330
}
331

    
332
static void do_change(const char *device, const char *filename)
333
{
334
    BlockDriverState *bs;
335
    int i;
336
    char password[256];
337

    
338
    bs = bdrv_find(device);
339
    if (!bs) {
340
        term_printf("device not found\n");
341
        return;
342
    }
343
    if (eject_device(bs, 0) < 0)
344
        return;
345
    bdrv_open(bs, filename, 0);
346
    if (bdrv_is_encrypted(bs)) {
347
        term_printf("%s is encrypted.\n", device);
348
        for(i = 0; i < 3; i++) {
349
            monitor_readline("Password: ", 1, password, sizeof(password));
350
            if (bdrv_set_key(bs, password) == 0)
351
                break;
352
            term_printf("invalid password\n");
353
        }
354
    }
355
}
356

    
357
static void do_screen_dump(const char *filename)
358
{
359
    vga_hw_screen_dump(filename);
360
}
361

    
362
static void do_log(const char *items)
363
{
364
    int mask;
365
    
366
    if (!strcmp(items, "none")) {
367
        mask = 0;
368
    } else {
369
        mask = cpu_str_to_log_mask(items);
370
        if (!mask) {
371
            help_cmd("log");
372
            return;
373
        }
374
    }
375
    cpu_set_log(mask);
376
}
377

    
378
static void do_savevm(const char *filename)
379
{
380
    if (qemu_savevm(filename) < 0)
381
        term_printf("I/O error when saving VM to '%s'\n", filename);
382
}
383

    
384
static void do_loadvm(const char *filename)
385
{
386
    if (qemu_loadvm(filename) < 0) 
387
        term_printf("I/O error when loading VM from '%s'\n", filename);
388
}
389

    
390
static void do_stop(void)
391
{
392
    vm_stop(EXCP_INTERRUPT);
393
}
394

    
395
static void do_cont(void)
396
{
397
    vm_start();
398
}
399

    
400
#ifdef CONFIG_GDBSTUB
401
static void do_gdbserver(int has_port, int port)
402
{
403
    if (!has_port)
404
        port = DEFAULT_GDBSTUB_PORT;
405
    if (gdbserver_start(port) < 0) {
406
        qemu_printf("Could not open gdbserver socket on port %d\n", port);
407
    } else {
408
        qemu_printf("Waiting gdb connection on port %d\n", port);
409
    }
410
}
411
#endif
412

    
413
static void term_printc(int c)
414
{
415
    term_printf("'");
416
    switch(c) {
417
    case '\'':
418
        term_printf("\\'");
419
        break;
420
    case '\\':
421
        term_printf("\\\\");
422
        break;
423
    case '\n':
424
        term_printf("\\n");
425
        break;
426
    case '\r':
427
        term_printf("\\r");
428
        break;
429
    default:
430
        if (c >= 32 && c <= 126) {
431
            term_printf("%c", c);
432
        } else {
433
            term_printf("\\x%02x", c);
434
        }
435
        break;
436
    }
437
    term_printf("'");
438
}
439

    
440
static void memory_dump(int count, int format, int wsize, 
441
                        target_ulong addr, int is_physical)
442
{
443
    CPUState *env;
444
    int nb_per_line, l, line_size, i, max_digits, len;
445
    uint8_t buf[16];
446
    uint64_t v;
447

    
448
    if (format == 'i') {
449
        int flags;
450
        flags = 0;
451
        env = mon_get_cpu();
452
        if (!env && !is_physical)
453
            return;
454
#ifdef TARGET_I386
455
        if (wsize == 2) {
456
            flags = 1;
457
        } else if (wsize == 4) {
458
            flags = 0;
459
        } else {
460
            /* as default we use the current CS size */
461
            flags = 0;
462
            if (env) {
463
#ifdef TARGET_X86_64
464
                if ((env->efer & MSR_EFER_LMA) && 
465
                    (env->segs[R_CS].flags & DESC_L_MASK))
466
                    flags = 2;
467
                else
468
#endif
469
                if (!(env->segs[R_CS].flags & DESC_B_MASK))
470
                    flags = 1;
471
            }
472
        }
473
#endif
474
        monitor_disas(env, addr, count, is_physical, flags);
475
        return;
476
    }
477

    
478
    len = wsize * count;
479
    if (wsize == 1)
480
        line_size = 8;
481
    else
482
        line_size = 16;
483
    nb_per_line = line_size / wsize;
484
    max_digits = 0;
485

    
486
    switch(format) {
487
    case 'o':
488
        max_digits = (wsize * 8 + 2) / 3;
489
        break;
490
    default:
491
    case 'x':
492
        max_digits = (wsize * 8) / 4;
493
        break;
494
    case 'u':
495
    case 'd':
496
        max_digits = (wsize * 8 * 10 + 32) / 33;
497
        break;
498
    case 'c':
499
        wsize = 1;
500
        break;
501
    }
502

    
503
    while (len > 0) {
504
        term_printf(TARGET_FMT_lx ":", addr);
505
        l = len;
506
        if (l > line_size)
507
            l = line_size;
508
        if (is_physical) {
509
            cpu_physical_memory_rw(addr, buf, l, 0);
510
        } else {
511
            env = mon_get_cpu();
512
            if (!env)
513
                break;
514
            cpu_memory_rw_debug(env, addr, buf, l, 0);
515
        }
516
        i = 0; 
517
        while (i < l) {
518
            switch(wsize) {
519
            default:
520
            case 1:
521
                v = ldub_raw(buf + i);
522
                break;
523
            case 2:
524
                v = lduw_raw(buf + i);
525
                break;
526
            case 4:
527
                v = (uint32_t)ldl_raw(buf + i);
528
                break;
529
            case 8:
530
                v = ldq_raw(buf + i);
531
                break;
532
            }
533
            term_printf(" ");
534
            switch(format) {
535
            case 'o':
536
                term_printf("%#*" PRIo64, max_digits, v);
537
                break;
538
            case 'x':
539
                term_printf("0x%0*" PRIx64, max_digits, v);
540
                break;
541
            case 'u':
542
                term_printf("%*" PRIu64, max_digits, v);
543
                break;
544
            case 'd':
545
                term_printf("%*" PRId64, max_digits, v);
546
                break;
547
            case 'c':
548
                term_printc(v);
549
                break;
550
            }
551
            i += wsize;
552
        }
553
        term_printf("\n");
554
        addr += l;
555
        len -= l;
556
    }
557
}
558

    
559
#if TARGET_LONG_BITS == 64
560
#define GET_TLONG(h, l) (((uint64_t)(h) << 32) | (l))
561
#else
562
#define GET_TLONG(h, l) (l)
563
#endif
564

    
565
static void do_memory_dump(int count, int format, int size, 
566
                           uint32_t addrh, uint32_t addrl)
567
{
568
    target_long addr = GET_TLONG(addrh, addrl);
569
    memory_dump(count, format, size, addr, 0);
570
}
571

    
572
static void do_physical_memory_dump(int count, int format, int size,
573
                                    uint32_t addrh, uint32_t addrl)
574

    
575
{
576
    target_long addr = GET_TLONG(addrh, addrl);
577
    memory_dump(count, format, size, addr, 1);
578
}
579

    
580
static void do_print(int count, int format, int size, unsigned int valh, unsigned int vall)
581
{
582
    target_long val = GET_TLONG(valh, vall);
583
#if TARGET_LONG_BITS == 32
584
    switch(format) {
585
    case 'o':
586
        term_printf("%#o", val);
587
        break;
588
    case 'x':
589
        term_printf("%#x", val);
590
        break;
591
    case 'u':
592
        term_printf("%u", val);
593
        break;
594
    default:
595
    case 'd':
596
        term_printf("%d", val);
597
        break;
598
    case 'c':
599
        term_printc(val);
600
        break;
601
    }
602
#else
603
    switch(format) {
604
    case 'o':
605
        term_printf("%#" PRIo64, val);
606
        break;
607
    case 'x':
608
        term_printf("%#" PRIx64, val);
609
        break;
610
    case 'u':
611
        term_printf("%" PRIu64, val);
612
        break;
613
    default:
614
    case 'd':
615
        term_printf("%" PRId64, val);
616
        break;
617
    case 'c':
618
        term_printc(val);
619
        break;
620
    }
621
#endif
622
    term_printf("\n");
623
}
624

    
625
static void do_sum(uint32_t start, uint32_t size)
626
{
627
    uint32_t addr;
628
    uint8_t buf[1];
629
    uint16_t sum;
630

    
631
    sum = 0;
632
    for(addr = start; addr < (start + size); addr++) {
633
        cpu_physical_memory_rw(addr, buf, 1, 0);
634
        /* BSD sum algorithm ('sum' Unix command) */
635
        sum = (sum >> 1) | (sum << 15);
636
        sum += buf[0];
637
    }
638
    term_printf("%05d\n", sum);
639
}
640

    
641
typedef struct {
642
    int keycode;
643
    const char *name;
644
} KeyDef;
645

    
646
static const KeyDef key_defs[] = {
647
    { 0x2a, "shift" },
648
    { 0x36, "shift_r" },
649
    
650
    { 0x38, "alt" },
651
    { 0xb8, "alt_r" },
652
    { 0x1d, "ctrl" },
653
    { 0x9d, "ctrl_r" },
654

    
655
    { 0xdd, "menu" },
656

    
657
    { 0x01, "esc" },
658

    
659
    { 0x02, "1" },
660
    { 0x03, "2" },
661
    { 0x04, "3" },
662
    { 0x05, "4" },
663
    { 0x06, "5" },
664
    { 0x07, "6" },
665
    { 0x08, "7" },
666
    { 0x09, "8" },
667
    { 0x0a, "9" },
668
    { 0x0b, "0" },
669
    { 0x0c, "minus" },
670
    { 0x0d, "equal" },
671
    { 0x0e, "backspace" },
672

    
673
    { 0x0f, "tab" },
674
    { 0x10, "q" },
675
    { 0x11, "w" },
676
    { 0x12, "e" },
677
    { 0x13, "r" },
678
    { 0x14, "t" },
679
    { 0x15, "y" },
680
    { 0x16, "u" },
681
    { 0x17, "i" },
682
    { 0x18, "o" },
683
    { 0x19, "p" },
684

    
685
    { 0x1c, "ret" },
686

    
687
    { 0x1e, "a" },
688
    { 0x1f, "s" },
689
    { 0x20, "d" },
690
    { 0x21, "f" },
691
    { 0x22, "g" },
692
    { 0x23, "h" },
693
    { 0x24, "j" },
694
    { 0x25, "k" },
695
    { 0x26, "l" },
696

    
697
    { 0x2c, "z" },
698
    { 0x2d, "x" },
699
    { 0x2e, "c" },
700
    { 0x2f, "v" },
701
    { 0x30, "b" },
702
    { 0x31, "n" },
703
    { 0x32, "m" },
704
    
705
    { 0x39, "spc" },
706
    { 0x3a, "caps_lock" },
707
    { 0x3b, "f1" },
708
    { 0x3c, "f2" },
709
    { 0x3d, "f3" },
710
    { 0x3e, "f4" },
711
    { 0x3f, "f5" },
712
    { 0x40, "f6" },
713
    { 0x41, "f7" },
714
    { 0x42, "f8" },
715
    { 0x43, "f9" },
716
    { 0x44, "f10" },
717
    { 0x45, "num_lock" },
718
    { 0x46, "scroll_lock" },
719

    
720
    { 0xb5, "kp_divide" },
721
    { 0x37, "kp_multiply" },
722
    { 0x4a, "kp_substract" },
723
    { 0x4e, "kp_add" },
724
    { 0x9c, "kp_enter" },
725
    { 0x53, "kp_decimal" },
726

    
727
    { 0x52, "kp_0" },
728
    { 0x4f, "kp_1" },
729
    { 0x50, "kp_2" },
730
    { 0x51, "kp_3" },
731
    { 0x4b, "kp_4" },
732
    { 0x4c, "kp_5" },
733
    { 0x4d, "kp_6" },
734
    { 0x47, "kp_7" },
735
    { 0x48, "kp_8" },
736
    { 0x49, "kp_9" },
737
    
738
    { 0x56, "<" },
739

    
740
    { 0x57, "f11" },
741
    { 0x58, "f12" },
742

    
743
    { 0xb7, "print" },
744

    
745
    { 0xc7, "home" },
746
    { 0xc9, "pgup" },
747
    { 0xd1, "pgdn" },
748
    { 0xcf, "end" },
749

    
750
    { 0xcb, "left" },
751
    { 0xc8, "up" },
752
    { 0xd0, "down" },
753
    { 0xcd, "right" },
754

    
755
    { 0xd2, "insert" },
756
    { 0xd3, "delete" },
757
    { 0, NULL },
758
};
759

    
760
static int get_keycode(const char *key)
761
{
762
    const KeyDef *p;
763
    char *endp;
764
    int ret;
765

    
766
    for(p = key_defs; p->name != NULL; p++) {
767
        if (!strcmp(key, p->name))
768
            return p->keycode;
769
    }
770
    if (strstart(key, "0x", NULL)) {
771
        ret = strtoul(key, &endp, 0);
772
        if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
773
            return ret;
774
    }
775
    return -1;
776
}
777

    
778
static void do_send_key(const char *string)
779
{
780
    char keybuf[16], *q;
781
    uint8_t keycodes[16];
782
    const char *p;
783
    int nb_keycodes, keycode, i;
784
    
785
    nb_keycodes = 0;
786
    p = string;
787
    while (*p != '\0') {
788
        q = keybuf;
789
        while (*p != '\0' && *p != '-') {
790
            if ((q - keybuf) < sizeof(keybuf) - 1) {
791
                *q++ = *p;
792
            }
793
            p++;
794
        }
795
        *q = '\0';
796
        keycode = get_keycode(keybuf);
797
        if (keycode < 0) {
798
            term_printf("unknown key: '%s'\n", keybuf);
799
            return;
800
        }
801
        keycodes[nb_keycodes++] = keycode;
802
        if (*p == '\0')
803
            break;
804
        p++;
805
    }
806
    /* key down events */
807
    for(i = 0; i < nb_keycodes; i++) {
808
        keycode = keycodes[i];
809
        if (keycode & 0x80)
810
            kbd_put_keycode(0xe0);
811
        kbd_put_keycode(keycode & 0x7f);
812
    }
813
    /* key up events */
814
    for(i = nb_keycodes - 1; i >= 0; i--) {
815
        keycode = keycodes[i];
816
        if (keycode & 0x80)
817
            kbd_put_keycode(0xe0);
818
        kbd_put_keycode(keycode | 0x80);
819
    }
820
}
821

    
822
static void do_ioport_read(int count, int format, int size, int addr, int has_index, int index)
823
{
824
    uint32_t val;
825
    int suffix;
826

    
827
    if (has_index) {
828
        cpu_outb(NULL, addr & 0xffff, index & 0xff);
829
        addr++;
830
    }
831
    addr &= 0xffff;
832

    
833
    switch(size) {
834
    default:
835
    case 1:
836
        val = cpu_inb(NULL, addr);
837
        suffix = 'b';
838
        break;
839
    case 2:
840
        val = cpu_inw(NULL, addr);
841
        suffix = 'w';
842
        break;
843
    case 4:
844
        val = cpu_inl(NULL, addr);
845
        suffix = 'l';
846
        break;
847
    }
848
    term_printf("port%c[0x%04x] = %#0*x\n",
849
                suffix, addr, size * 2, val);
850
}
851

    
852
static void do_system_reset(void)
853
{
854
    qemu_system_reset_request();
855
}
856

    
857
static void do_system_powerdown(void)
858
{
859
    qemu_system_powerdown_request();
860
}
861

    
862
#if defined(TARGET_I386)
863
static void print_pte(uint32_t addr, uint32_t pte, uint32_t mask)
864
{
865
    term_printf("%08x: %08x %c%c%c%c%c%c%c%c\n", 
866
                addr,
867
                pte & mask,
868
                pte & PG_GLOBAL_MASK ? 'G' : '-',
869
                pte & PG_PSE_MASK ? 'P' : '-',
870
                pte & PG_DIRTY_MASK ? 'D' : '-',
871
                pte & PG_ACCESSED_MASK ? 'A' : '-',
872
                pte & PG_PCD_MASK ? 'C' : '-',
873
                pte & PG_PWT_MASK ? 'T' : '-',
874
                pte & PG_USER_MASK ? 'U' : '-',
875
                pte & PG_RW_MASK ? 'W' : '-');
876
}
877

    
878
static void tlb_info(void)
879
{
880
    CPUState *env;
881
    int l1, l2;
882
    uint32_t pgd, pde, pte;
883

    
884
    env = mon_get_cpu();
885
    if (!env)
886
        return;
887

    
888
    if (!(env->cr[0] & CR0_PG_MASK)) {
889
        term_printf("PG disabled\n");
890
        return;
891
    }
892
    pgd = env->cr[3] & ~0xfff;
893
    for(l1 = 0; l1 < 1024; l1++) {
894
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
895
        pde = le32_to_cpu(pde);
896
        if (pde & PG_PRESENT_MASK) {
897
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
898
                print_pte((l1 << 22), pde, ~((1 << 20) - 1));
899
            } else {
900
                for(l2 = 0; l2 < 1024; l2++) {
901
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, 
902
                                             (uint8_t *)&pte, 4);
903
                    pte = le32_to_cpu(pte);
904
                    if (pte & PG_PRESENT_MASK) {
905
                        print_pte((l1 << 22) + (l2 << 12), 
906
                                  pte & ~PG_PSE_MASK, 
907
                                  ~0xfff);
908
                    }
909
                }
910
            }
911
        }
912
    }
913
}
914

    
915
static void mem_print(uint32_t *pstart, int *plast_prot, 
916
                      uint32_t end, int prot)
917
{
918
    int prot1;
919
    prot1 = *plast_prot;
920
    if (prot != prot1) {
921
        if (*pstart != -1) {
922
            term_printf("%08x-%08x %08x %c%c%c\n",
923
                        *pstart, end, end - *pstart, 
924
                        prot1 & PG_USER_MASK ? 'u' : '-',
925
                        'r',
926
                        prot1 & PG_RW_MASK ? 'w' : '-');
927
        }
928
        if (prot != 0)
929
            *pstart = end;
930
        else
931
            *pstart = -1;
932
        *plast_prot = prot;
933
    }
934
}
935

    
936
static void mem_info(void)
937
{
938
    CPUState *env;
939
    int l1, l2, prot, last_prot;
940
    uint32_t pgd, pde, pte, start, end;
941

    
942
    env = mon_get_cpu();
943
    if (!env)
944
        return;
945

    
946
    if (!(env->cr[0] & CR0_PG_MASK)) {
947
        term_printf("PG disabled\n");
948
        return;
949
    }
950
    pgd = env->cr[3] & ~0xfff;
951
    last_prot = 0;
952
    start = -1;
953
    for(l1 = 0; l1 < 1024; l1++) {
954
        cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
955
        pde = le32_to_cpu(pde);
956
        end = l1 << 22;
957
        if (pde & PG_PRESENT_MASK) {
958
            if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
959
                prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
960
                mem_print(&start, &last_prot, end, prot);
961
            } else {
962
                for(l2 = 0; l2 < 1024; l2++) {
963
                    cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, 
964
                                             (uint8_t *)&pte, 4);
965
                    pte = le32_to_cpu(pte);
966
                    end = (l1 << 22) + (l2 << 12);
967
                    if (pte & PG_PRESENT_MASK) {
968
                        prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
969
                    } else {
970
                        prot = 0;
971
                    }
972
                    mem_print(&start, &last_prot, end, prot);
973
                }
974
            }
975
        } else {
976
            prot = 0;
977
            mem_print(&start, &last_prot, end, prot);
978
        }
979
    }
980
}
981
#endif
982

    
983
static void do_info_kqemu(void)
984
{
985
#ifdef USE_KQEMU
986
    CPUState *env;
987
    int val;
988
    val = 0;
989
    env = mon_get_cpu();
990
    if (!env) {
991
        term_printf("No cpu initialized yet");
992
        return;
993
    }
994
    val = env->kqemu_enabled;
995
    term_printf("kqemu support: ");
996
    switch(val) {
997
    default:
998
    case 0:
999
        term_printf("disabled\n");
1000
        break;
1001
    case 1:
1002
        term_printf("enabled for user code\n");
1003
        break;
1004
    case 2:
1005
        term_printf("enabled for user and kernel code\n");
1006
        break;
1007
    }
1008
#else
1009
    term_printf("kqemu support: not compiled\n");
1010
#endif
1011
} 
1012

    
1013
#ifdef CONFIG_PROFILER
1014

    
1015
int64_t kqemu_time;
1016
int64_t qemu_time;
1017
int64_t kqemu_exec_count;
1018
int64_t dev_time;
1019
int64_t kqemu_ret_int_count;
1020
int64_t kqemu_ret_excp_count;
1021
int64_t kqemu_ret_intr_count;
1022

    
1023
static void do_info_profile(void)
1024
{
1025
    int64_t total;
1026
    total = qemu_time;
1027
    if (total == 0)
1028
        total = 1;
1029
    term_printf("async time  %" PRId64 " (%0.3f)\n",
1030
                dev_time, dev_time / (double)ticks_per_sec);
1031
    term_printf("qemu time   %" PRId64 " (%0.3f)\n",
1032
                qemu_time, qemu_time / (double)ticks_per_sec);
1033
    term_printf("kqemu time  %" PRId64 " (%0.3f %0.1f%%) count=%" PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%" PRId64 "\n",
1034
                kqemu_time, kqemu_time / (double)ticks_per_sec,
1035
                kqemu_time / (double)total * 100.0,
1036
                kqemu_exec_count,
1037
                kqemu_ret_int_count,
1038
                kqemu_ret_excp_count,
1039
                kqemu_ret_intr_count);
1040
    qemu_time = 0;
1041
    kqemu_time = 0;
1042
    kqemu_exec_count = 0;
1043
    dev_time = 0;
1044
    kqemu_ret_int_count = 0;
1045
    kqemu_ret_excp_count = 0;
1046
    kqemu_ret_intr_count = 0;
1047
#ifdef USE_KQEMU
1048
    kqemu_record_dump();
1049
#endif
1050
}
1051
#else
1052
static void do_info_profile(void)
1053
{
1054
    term_printf("Internal profiler not compiled\n");
1055
}
1056
#endif
1057

    
1058
static term_cmd_t term_cmds[] = {
1059
    { "help|?", "s?", do_help, 
1060
      "[cmd]", "show the help" },
1061
    { "commit", "", do_commit, 
1062
      "", "commit changes to the disk images (if -snapshot is used)" },
1063
    { "info", "s?", do_info,
1064
      "subcommand", "show various information about the system state" },
1065
    { "q|quit", "", do_quit,
1066
      "", "quit the emulator" },
1067
    { "eject", "-fB", do_eject,
1068
      "[-f] device", "eject a removable media (use -f to force it)" },
1069
    { "change", "BF", do_change,
1070
      "device filename", "change a removable media" },
1071
    { "screendump", "F", do_screen_dump, 
1072
      "filename", "save screen into PPM image 'filename'" },
1073
    { "log", "s", do_log,
1074
      "item1[,...]", "activate logging of the specified items to '/tmp/qemu.log'" }, 
1075
    { "savevm", "F", do_savevm,
1076
      "filename", "save the whole virtual machine state to 'filename'" }, 
1077
    { "loadvm", "F", do_loadvm,
1078
      "filename", "restore the whole virtual machine state from 'filename'" }, 
1079
    { "stop", "", do_stop, 
1080
      "", "stop emulation", },
1081
    { "c|cont", "", do_cont, 
1082
      "", "resume emulation", },
1083
#ifdef CONFIG_GDBSTUB
1084
    { "gdbserver", "i?", do_gdbserver, 
1085
      "[port]", "start gdbserver session (default port=1234)", },
1086
#endif
1087
    { "x", "/l", do_memory_dump, 
1088
      "/fmt addr", "virtual memory dump starting at 'addr'", },
1089
    { "xp", "/l", do_physical_memory_dump, 
1090
      "/fmt addr", "physical memory dump starting at 'addr'", },
1091
    { "p|print", "/l", do_print, 
1092
      "/fmt expr", "print expression value (use $reg for CPU register access)", },
1093
    { "i", "/ii.", do_ioport_read, 
1094
      "/fmt addr", "I/O port read" },
1095

    
1096
    { "sendkey", "s", do_send_key, 
1097
      "keys", "send keys to the VM (e.g. 'sendkey ctrl-alt-f1')" },
1098
    { "system_reset", "", do_system_reset, 
1099
      "", "reset the system" },
1100
    { "system_powerdown", "", do_system_powerdown, 
1101
      "", "send system power down event" },
1102
    { "sum", "ii", do_sum, 
1103
      "addr size", "compute the checksum of a memory region" },
1104
    { "usb_add", "s", do_usb_add,
1105
      "device", "add USB device (e.g. 'host:bus.addr' or 'host:vendor_id:product_id')" },
1106
    { "usb_del", "s", do_usb_del,
1107
      "device", "remove USB device 'bus.addr'" },
1108
    { "cpu", "i", do_cpu_set, 
1109
      "index", "set the default CPU" },
1110
    { NULL, NULL, }, 
1111
};
1112

    
1113
static term_cmd_t info_cmds[] = {
1114
    { "version", "", do_info_version,
1115
      "", "show the version of qemu" },
1116
    { "network", "", do_info_network,
1117
      "", "show the network state" },
1118
    { "block", "", do_info_block,
1119
      "", "show the block devices" },
1120
    { "registers", "", do_info_registers,
1121
      "", "show the cpu registers" },
1122
    { "cpus", "", do_info_cpus,
1123
      "", "show infos for each CPU" },
1124
    { "history", "", do_info_history,
1125
      "", "show the command line history", },
1126
    { "irq", "", irq_info,
1127
      "", "show the interrupts statistics (if available)", },
1128
    { "pic", "", pic_info,
1129
      "", "show i8259 (PIC) state", },
1130
    { "pci", "", pci_info,
1131
      "", "show PCI info", },
1132
#if defined(TARGET_I386)
1133
    { "tlb", "", tlb_info,
1134
      "", "show virtual to physical memory mappings", },
1135
    { "mem", "", mem_info,
1136
      "", "show the active virtual memory mappings", },
1137
#endif
1138
    { "jit", "", do_info_jit,
1139
      "", "show dynamic compiler info", },
1140
    { "kqemu", "", do_info_kqemu,
1141
      "", "show kqemu information", },
1142
    { "usb", "", usb_info,
1143
      "", "show guest USB devices", },
1144
    { "usbhost", "", usb_host_info,
1145
      "", "show host USB devices", },
1146
    { "profile", "", do_info_profile,
1147
      "", "show profiling information", },
1148
    { NULL, NULL, },
1149
};
1150

    
1151
/*******************************************************************/
1152

    
1153
static const char *pch;
1154
static jmp_buf expr_env;
1155

    
1156
#define MD_TLONG 0
1157
#define MD_I32   1
1158

    
1159
typedef struct MonitorDef {
1160
    const char *name;
1161
    int offset;
1162
    target_long (*get_value)(struct MonitorDef *md, int val);
1163
    int type;
1164
} MonitorDef;
1165

    
1166
#if defined(TARGET_I386)
1167
static target_long monitor_get_pc (struct MonitorDef *md, int val)
1168
{
1169
    CPUState *env = mon_get_cpu();
1170
    if (!env)
1171
        return 0;
1172
    return env->eip + env->segs[R_CS].base;
1173
}
1174
#endif
1175

    
1176
#if defined(TARGET_PPC)
1177
static target_long monitor_get_ccr (struct MonitorDef *md, int val)
1178
{
1179
    CPUState *env = mon_get_cpu();
1180
    unsigned int u;
1181
    int i;
1182

    
1183
    if (!env)
1184
        return 0;
1185

    
1186
    u = 0;
1187
    for (i = 0; i < 8; i++)
1188
        u |= env->crf[i] << (32 - (4 * i));
1189

    
1190
    return u;
1191
}
1192

    
1193
static target_long monitor_get_msr (struct MonitorDef *md, int val)
1194
{
1195
    CPUState *env = mon_get_cpu();
1196
    if (!env)
1197
        return 0;
1198
    return (env->msr[MSR_POW] << MSR_POW) |
1199
        (env->msr[MSR_ILE] << MSR_ILE) |
1200
        (env->msr[MSR_EE] << MSR_EE) |
1201
        (env->msr[MSR_PR] << MSR_PR) |
1202
        (env->msr[MSR_FP] << MSR_FP) |
1203
        (env->msr[MSR_ME] << MSR_ME) |
1204
        (env->msr[MSR_FE0] << MSR_FE0) |
1205
        (env->msr[MSR_SE] << MSR_SE) |
1206
        (env->msr[MSR_BE] << MSR_BE) |
1207
        (env->msr[MSR_FE1] << MSR_FE1) |
1208
        (env->msr[MSR_IP] << MSR_IP) |
1209
        (env->msr[MSR_IR] << MSR_IR) |
1210
        (env->msr[MSR_DR] << MSR_DR) |
1211
        (env->msr[MSR_RI] << MSR_RI) |
1212
        (env->msr[MSR_LE] << MSR_LE);
1213
}
1214

    
1215
static target_long monitor_get_xer (struct MonitorDef *md, int val)
1216
{
1217
    CPUState *env = mon_get_cpu();
1218
    if (!env)
1219
        return 0;
1220
    return (env->xer[XER_SO] << XER_SO) |
1221
        (env->xer[XER_OV] << XER_OV) |
1222
        (env->xer[XER_CA] << XER_CA) |
1223
        (env->xer[XER_BC] << XER_BC);
1224
}
1225

    
1226
static target_long monitor_get_decr (struct MonitorDef *md, int val)
1227
{
1228
    CPUState *env = mon_get_cpu();
1229
    if (!env)
1230
        return 0;
1231
    return cpu_ppc_load_decr(env);
1232
}
1233

    
1234
static target_long monitor_get_tbu (struct MonitorDef *md, int val)
1235
{
1236
    CPUState *env = mon_get_cpu();
1237
    if (!env)
1238
        return 0;
1239
    return cpu_ppc_load_tbu(env);
1240
}
1241

    
1242
static target_long monitor_get_tbl (struct MonitorDef *md, int val)
1243
{
1244
    CPUState *env = mon_get_cpu();
1245
    if (!env)
1246
        return 0;
1247
    return cpu_ppc_load_tbl(env);
1248
}
1249
#endif
1250

    
1251
#if defined(TARGET_SPARC)
1252
#ifndef TARGET_SPARC64
1253
static target_long monitor_get_psr (struct MonitorDef *md, int val)
1254
{
1255
    CPUState *env = mon_get_cpu();
1256
    if (!env)
1257
        return 0;
1258
    return GET_PSR(env);
1259
}
1260
#endif
1261

    
1262
static target_long monitor_get_reg(struct MonitorDef *md, int val)
1263
{
1264
    CPUState *env = mon_get_cpu();
1265
    if (!env)
1266
        return 0;
1267
    return env->regwptr[val];
1268
}
1269
#endif
1270

    
1271
static MonitorDef monitor_defs[] = {
1272
#ifdef TARGET_I386
1273

    
1274
#define SEG(name, seg) \
1275
    { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
1276
    { name ".base", offsetof(CPUState, segs[seg].base) },\
1277
    { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
1278

    
1279
    { "eax", offsetof(CPUState, regs[0]) },
1280
    { "ecx", offsetof(CPUState, regs[1]) },
1281
    { "edx", offsetof(CPUState, regs[2]) },
1282
    { "ebx", offsetof(CPUState, regs[3]) },
1283
    { "esp|sp", offsetof(CPUState, regs[4]) },
1284
    { "ebp|fp", offsetof(CPUState, regs[5]) },
1285
    { "esi", offsetof(CPUState, regs[6]) },
1286
    { "edi", offsetof(CPUState, regs[7]) },
1287
#ifdef TARGET_X86_64
1288
    { "r8", offsetof(CPUState, regs[8]) },
1289
    { "r9", offsetof(CPUState, regs[9]) },
1290
    { "r10", offsetof(CPUState, regs[10]) },
1291
    { "r11", offsetof(CPUState, regs[11]) },
1292
    { "r12", offsetof(CPUState, regs[12]) },
1293
    { "r13", offsetof(CPUState, regs[13]) },
1294
    { "r14", offsetof(CPUState, regs[14]) },
1295
    { "r15", offsetof(CPUState, regs[15]) },
1296
#endif
1297
    { "eflags", offsetof(CPUState, eflags) },
1298
    { "eip", offsetof(CPUState, eip) },
1299
    SEG("cs", R_CS)
1300
    SEG("ds", R_DS)
1301
    SEG("es", R_ES)
1302
    SEG("ss", R_SS)
1303
    SEG("fs", R_FS)
1304
    SEG("gs", R_GS)
1305
    { "pc", 0, monitor_get_pc, },
1306
#elif defined(TARGET_PPC)
1307
    { "r0", offsetof(CPUState, gpr[0]) },
1308
    { "r1", offsetof(CPUState, gpr[1]) },
1309
    { "r2", offsetof(CPUState, gpr[2]) },
1310
    { "r3", offsetof(CPUState, gpr[3]) },
1311
    { "r4", offsetof(CPUState, gpr[4]) },
1312
    { "r5", offsetof(CPUState, gpr[5]) },
1313
    { "r6", offsetof(CPUState, gpr[6]) },
1314
    { "r7", offsetof(CPUState, gpr[7]) },
1315
    { "r8", offsetof(CPUState, gpr[8]) },
1316
    { "r9", offsetof(CPUState, gpr[9]) },
1317
    { "r10", offsetof(CPUState, gpr[10]) },
1318
    { "r11", offsetof(CPUState, gpr[11]) },
1319
    { "r12", offsetof(CPUState, gpr[12]) },
1320
    { "r13", offsetof(CPUState, gpr[13]) },
1321
    { "r14", offsetof(CPUState, gpr[14]) },
1322
    { "r15", offsetof(CPUState, gpr[15]) },
1323
    { "r16", offsetof(CPUState, gpr[16]) },
1324
    { "r17", offsetof(CPUState, gpr[17]) },
1325
    { "r18", offsetof(CPUState, gpr[18]) },
1326
    { "r19", offsetof(CPUState, gpr[19]) },
1327
    { "r20", offsetof(CPUState, gpr[20]) },
1328
    { "r21", offsetof(CPUState, gpr[21]) },
1329
    { "r22", offsetof(CPUState, gpr[22]) },
1330
    { "r23", offsetof(CPUState, gpr[23]) },
1331
    { "r24", offsetof(CPUState, gpr[24]) },
1332
    { "r25", offsetof(CPUState, gpr[25]) },
1333
    { "r26", offsetof(CPUState, gpr[26]) },
1334
    { "r27", offsetof(CPUState, gpr[27]) },
1335
    { "r28", offsetof(CPUState, gpr[28]) },
1336
    { "r29", offsetof(CPUState, gpr[29]) },
1337
    { "r30", offsetof(CPUState, gpr[30]) },
1338
    { "r31", offsetof(CPUState, gpr[31]) },
1339
    { "nip|pc", offsetof(CPUState, nip) },
1340
    { "lr", offsetof(CPUState, lr) },
1341
    { "ctr", offsetof(CPUState, ctr) },
1342
    { "decr", 0, &monitor_get_decr, },
1343
    { "ccr", 0, &monitor_get_ccr, },
1344
    { "msr", 0, &monitor_get_msr, },
1345
    { "xer", 0, &monitor_get_xer, },
1346
    { "tbu", 0, &monitor_get_tbu, },
1347
    { "tbl", 0, &monitor_get_tbl, },
1348
    { "sdr1", offsetof(CPUState, sdr1) },
1349
    { "sr0", offsetof(CPUState, sr[0]) },
1350
    { "sr1", offsetof(CPUState, sr[1]) },
1351
    { "sr2", offsetof(CPUState, sr[2]) },
1352
    { "sr3", offsetof(CPUState, sr[3]) },
1353
    { "sr4", offsetof(CPUState, sr[4]) },
1354
    { "sr5", offsetof(CPUState, sr[5]) },
1355
    { "sr6", offsetof(CPUState, sr[6]) },
1356
    { "sr7", offsetof(CPUState, sr[7]) },
1357
    { "sr8", offsetof(CPUState, sr[8]) },
1358
    { "sr9", offsetof(CPUState, sr[9]) },
1359
    { "sr10", offsetof(CPUState, sr[10]) },
1360
    { "sr11", offsetof(CPUState, sr[11]) },
1361
    { "sr12", offsetof(CPUState, sr[12]) },
1362
    { "sr13", offsetof(CPUState, sr[13]) },
1363
    { "sr14", offsetof(CPUState, sr[14]) },
1364
    { "sr15", offsetof(CPUState, sr[15]) },
1365
    /* Too lazy to put BATs and SPRs ... */
1366
#elif defined(TARGET_SPARC)
1367
    { "g0", offsetof(CPUState, gregs[0]) },
1368
    { "g1", offsetof(CPUState, gregs[1]) },
1369
    { "g2", offsetof(CPUState, gregs[2]) },
1370
    { "g3", offsetof(CPUState, gregs[3]) },
1371
    { "g4", offsetof(CPUState, gregs[4]) },
1372
    { "g5", offsetof(CPUState, gregs[5]) },
1373
    { "g6", offsetof(CPUState, gregs[6]) },
1374
    { "g7", offsetof(CPUState, gregs[7]) },
1375
    { "o0", 0, monitor_get_reg },
1376
    { "o1", 1, monitor_get_reg },
1377
    { "o2", 2, monitor_get_reg },
1378
    { "o3", 3, monitor_get_reg },
1379
    { "o4", 4, monitor_get_reg },
1380
    { "o5", 5, monitor_get_reg },
1381
    { "o6", 6, monitor_get_reg },
1382
    { "o7", 7, monitor_get_reg },
1383
    { "l0", 8, monitor_get_reg },
1384
    { "l1", 9, monitor_get_reg },
1385
    { "l2", 10, monitor_get_reg },
1386
    { "l3", 11, monitor_get_reg },
1387
    { "l4", 12, monitor_get_reg },
1388
    { "l5", 13, monitor_get_reg },
1389
    { "l6", 14, monitor_get_reg },
1390
    { "l7", 15, monitor_get_reg },
1391
    { "i0", 16, monitor_get_reg },
1392
    { "i1", 17, monitor_get_reg },
1393
    { "i2", 18, monitor_get_reg },
1394
    { "i3", 19, monitor_get_reg },
1395
    { "i4", 20, monitor_get_reg },
1396
    { "i5", 21, monitor_get_reg },
1397
    { "i6", 22, monitor_get_reg },
1398
    { "i7", 23, monitor_get_reg },
1399
    { "pc", offsetof(CPUState, pc) },
1400
    { "npc", offsetof(CPUState, npc) },
1401
    { "y", offsetof(CPUState, y) },
1402
#ifndef TARGET_SPARC64
1403
    { "psr", 0, &monitor_get_psr, },
1404
    { "wim", offsetof(CPUState, wim) },
1405
#endif
1406
    { "tbr", offsetof(CPUState, tbr) },
1407
    { "fsr", offsetof(CPUState, fsr) },
1408
    { "f0", offsetof(CPUState, fpr[0]) },
1409
    { "f1", offsetof(CPUState, fpr[1]) },
1410
    { "f2", offsetof(CPUState, fpr[2]) },
1411
    { "f3", offsetof(CPUState, fpr[3]) },
1412
    { "f4", offsetof(CPUState, fpr[4]) },
1413
    { "f5", offsetof(CPUState, fpr[5]) },
1414
    { "f6", offsetof(CPUState, fpr[6]) },
1415
    { "f7", offsetof(CPUState, fpr[7]) },
1416
    { "f8", offsetof(CPUState, fpr[8]) },
1417
    { "f9", offsetof(CPUState, fpr[9]) },
1418
    { "f10", offsetof(CPUState, fpr[10]) },
1419
    { "f11", offsetof(CPUState, fpr[11]) },
1420
    { "f12", offsetof(CPUState, fpr[12]) },
1421
    { "f13", offsetof(CPUState, fpr[13]) },
1422
    { "f14", offsetof(CPUState, fpr[14]) },
1423
    { "f15", offsetof(CPUState, fpr[15]) },
1424
    { "f16", offsetof(CPUState, fpr[16]) },
1425
    { "f17", offsetof(CPUState, fpr[17]) },
1426
    { "f18", offsetof(CPUState, fpr[18]) },
1427
    { "f19", offsetof(CPUState, fpr[19]) },
1428
    { "f20", offsetof(CPUState, fpr[20]) },
1429
    { "f21", offsetof(CPUState, fpr[21]) },
1430
    { "f22", offsetof(CPUState, fpr[22]) },
1431
    { "f23", offsetof(CPUState, fpr[23]) },
1432
    { "f24", offsetof(CPUState, fpr[24]) },
1433
    { "f25", offsetof(CPUState, fpr[25]) },
1434
    { "f26", offsetof(CPUState, fpr[26]) },
1435
    { "f27", offsetof(CPUState, fpr[27]) },
1436
    { "f28", offsetof(CPUState, fpr[28]) },
1437
    { "f29", offsetof(CPUState, fpr[29]) },
1438
    { "f30", offsetof(CPUState, fpr[30]) },
1439
    { "f31", offsetof(CPUState, fpr[31]) },
1440
#ifdef TARGET_SPARC64
1441
    { "f32", offsetof(CPUState, fpr[32]) },
1442
    { "f34", offsetof(CPUState, fpr[34]) },
1443
    { "f36", offsetof(CPUState, fpr[36]) },
1444
    { "f38", offsetof(CPUState, fpr[38]) },
1445
    { "f40", offsetof(CPUState, fpr[40]) },
1446
    { "f42", offsetof(CPUState, fpr[42]) },
1447
    { "f44", offsetof(CPUState, fpr[44]) },
1448
    { "f46", offsetof(CPUState, fpr[46]) },
1449
    { "f48", offsetof(CPUState, fpr[48]) },
1450
    { "f50", offsetof(CPUState, fpr[50]) },
1451
    { "f52", offsetof(CPUState, fpr[52]) },
1452
    { "f54", offsetof(CPUState, fpr[54]) },
1453
    { "f56", offsetof(CPUState, fpr[56]) },
1454
    { "f58", offsetof(CPUState, fpr[58]) },
1455
    { "f60", offsetof(CPUState, fpr[60]) },
1456
    { "f62", offsetof(CPUState, fpr[62]) },
1457
    { "asi", offsetof(CPUState, asi) },
1458
    { "pstate", offsetof(CPUState, pstate) },
1459
    { "cansave", offsetof(CPUState, cansave) },
1460
    { "canrestore", offsetof(CPUState, canrestore) },
1461
    { "otherwin", offsetof(CPUState, otherwin) },
1462
    { "wstate", offsetof(CPUState, wstate) },
1463
    { "cleanwin", offsetof(CPUState, cleanwin) },
1464
    { "fprs", offsetof(CPUState, fprs) },
1465
#endif
1466
#endif
1467
    { NULL },
1468
};
1469

    
1470
static void expr_error(const char *fmt) 
1471
{
1472
    term_printf(fmt);
1473
    term_printf("\n");
1474
    longjmp(expr_env, 1);
1475
}
1476

    
1477
/* return 0 if OK, -1 if not found, -2 if no CPU defined */
1478
static int get_monitor_def(target_long *pval, const char *name)
1479
{
1480
    MonitorDef *md;
1481
    void *ptr;
1482

    
1483
    for(md = monitor_defs; md->name != NULL; md++) {
1484
        if (compare_cmd(name, md->name)) {
1485
            if (md->get_value) {
1486
                *pval = md->get_value(md, md->offset);
1487
            } else {
1488
                CPUState *env = mon_get_cpu();
1489
                if (!env)
1490
                    return -2;
1491
                ptr = (uint8_t *)env + md->offset;
1492
                switch(md->type) {
1493
                case MD_I32:
1494
                    *pval = *(int32_t *)ptr;
1495
                    break;
1496
                case MD_TLONG:
1497
                    *pval = *(target_long *)ptr;
1498
                    break;
1499
                default:
1500
                    *pval = 0;
1501
                    break;
1502
                }
1503
            }
1504
            return 0;
1505
        }
1506
    }
1507
    return -1;
1508
}
1509

    
1510
static void next(void)
1511
{
1512
    if (pch != '\0') {
1513
        pch++;
1514
        while (isspace(*pch))
1515
            pch++;
1516
    }
1517
}
1518

    
1519
static target_long expr_sum(void);
1520

    
1521
static target_long expr_unary(void)
1522
{
1523
    target_long n;
1524
    char *p;
1525
    int ret;
1526

    
1527
    switch(*pch) {
1528
    case '+':
1529
        next();
1530
        n = expr_unary();
1531
        break;
1532
    case '-':
1533
        next();
1534
        n = -expr_unary();
1535
        break;
1536
    case '~':
1537
        next();
1538
        n = ~expr_unary();
1539
        break;
1540
    case '(':
1541
        next();
1542
        n = expr_sum();
1543
        if (*pch != ')') {
1544
            expr_error("')' expected");
1545
        }
1546
        next();
1547
        break;
1548
    case '\'':
1549
        pch++;
1550
        if (*pch == '\0')
1551
            expr_error("character constant expected");
1552
        n = *pch;
1553
        pch++;
1554
        if (*pch != '\'')
1555
            expr_error("missing terminating \' character");
1556
        next();
1557
        break;
1558
    case '$':
1559
        {
1560
            char buf[128], *q;
1561
            
1562
            pch++;
1563
            q = buf;
1564
            while ((*pch >= 'a' && *pch <= 'z') ||
1565
                   (*pch >= 'A' && *pch <= 'Z') ||
1566
                   (*pch >= '0' && *pch <= '9') ||
1567
                   *pch == '_' || *pch == '.') {
1568
                if ((q - buf) < sizeof(buf) - 1)
1569
                    *q++ = *pch;
1570
                pch++;
1571
            }
1572
            while (isspace(*pch))
1573
                pch++;
1574
            *q = 0;
1575
            ret = get_monitor_def(&n, buf);
1576
            if (ret == -1)
1577
                expr_error("unknown register");
1578
            else if (ret == -2) 
1579
                expr_error("no cpu defined");
1580
        }
1581
        break;
1582
    case '\0':
1583
        expr_error("unexpected end of expression");
1584
        n = 0;
1585
        break;
1586
    default:
1587
        /* XXX: 64 bit version */
1588
        n = strtoul(pch, &p, 0);
1589
        if (pch == p) {
1590
            expr_error("invalid char in expression");
1591
        }
1592
        pch = p;
1593
        while (isspace(*pch))
1594
            pch++;
1595
        break;
1596
    }
1597
    return n;
1598
}
1599

    
1600

    
1601
static target_long expr_prod(void)
1602
{
1603
    target_long val, val2;
1604
    int op;
1605
    
1606
    val = expr_unary();
1607
    for(;;) {
1608
        op = *pch;
1609
        if (op != '*' && op != '/' && op != '%')
1610
            break;
1611
        next();
1612
        val2 = expr_unary();
1613
        switch(op) {
1614
        default:
1615
        case '*':
1616
            val *= val2;
1617
            break;
1618
        case '/':
1619
        case '%':
1620
            if (val2 == 0) 
1621
                expr_error("division by zero");
1622
            if (op == '/')
1623
                val /= val2;
1624
            else
1625
                val %= val2;
1626
            break;
1627
        }
1628
    }
1629
    return val;
1630
}
1631

    
1632
static target_long expr_logic(void)
1633
{
1634
    target_long val, val2;
1635
    int op;
1636

    
1637
    val = expr_prod();
1638
    for(;;) {
1639
        op = *pch;
1640
        if (op != '&' && op != '|' && op != '^')
1641
            break;
1642
        next();
1643
        val2 = expr_prod();
1644
        switch(op) {
1645
        default:
1646
        case '&':
1647
            val &= val2;
1648
            break;
1649
        case '|':
1650
            val |= val2;
1651
            break;
1652
        case '^':
1653
            val ^= val2;
1654
            break;
1655
        }
1656
    }
1657
    return val;
1658
}
1659

    
1660
static target_long expr_sum(void)
1661
{
1662
    target_long val, val2;
1663
    int op;
1664

    
1665
    val = expr_logic();
1666
    for(;;) {
1667
        op = *pch;
1668
        if (op != '+' && op != '-')
1669
            break;
1670
        next();
1671
        val2 = expr_logic();
1672
        if (op == '+')
1673
            val += val2;
1674
        else
1675
            val -= val2;
1676
    }
1677
    return val;
1678
}
1679

    
1680
static int get_expr(target_long *pval, const char **pp)
1681
{
1682
    pch = *pp;
1683
    if (setjmp(expr_env)) {
1684
        *pp = pch;
1685
        return -1;
1686
    }
1687
    while (isspace(*pch))
1688
        pch++;
1689
    *pval = expr_sum();
1690
    *pp = pch;
1691
    return 0;
1692
}
1693

    
1694
static int get_str(char *buf, int buf_size, const char **pp)
1695
{
1696
    const char *p;
1697
    char *q;
1698
    int c;
1699

    
1700
    q = buf;
1701
    p = *pp;
1702
    while (isspace(*p))
1703
        p++;
1704
    if (*p == '\0') {
1705
    fail:
1706
        *q = '\0';
1707
        *pp = p;
1708
        return -1;
1709
    }
1710
    if (*p == '\"') {
1711
        p++;
1712
        while (*p != '\0' && *p != '\"') {
1713
            if (*p == '\\') {
1714
                p++;
1715
                c = *p++;
1716
                switch(c) {
1717
                case 'n':
1718
                    c = '\n';
1719
                    break;
1720
                case 'r':
1721
                    c = '\r';
1722
                    break;
1723
                case '\\':
1724
                case '\'':
1725
                case '\"':
1726
                    break;
1727
                default:
1728
                    qemu_printf("unsupported escape code: '\\%c'\n", c);
1729
                    goto fail;
1730
                }
1731
                if ((q - buf) < buf_size - 1) {
1732
                    *q++ = c;
1733
                }
1734
            } else {
1735
                if ((q - buf) < buf_size - 1) {
1736
                    *q++ = *p;
1737
                }
1738
                p++;
1739
            }
1740
        }
1741
        if (*p != '\"') {
1742
            qemu_printf("unterminated string\n");
1743
            goto fail;
1744
        }
1745
        p++;
1746
    } else {
1747
        while (*p != '\0' && !isspace(*p)) {
1748
            if ((q - buf) < buf_size - 1) {
1749
                *q++ = *p;
1750
            }
1751
            p++;
1752
        }
1753
    }
1754
    *q = '\0';
1755
    *pp = p;
1756
    return 0;
1757
}
1758

    
1759
static int default_fmt_format = 'x';
1760
static int default_fmt_size = 4;
1761

    
1762
#define MAX_ARGS 16
1763

    
1764
static void monitor_handle_command(const char *cmdline)
1765
{
1766
    const char *p, *pstart, *typestr;
1767
    char *q;
1768
    int c, nb_args, len, i, has_arg;
1769
    term_cmd_t *cmd;
1770
    char cmdname[256];
1771
    char buf[1024];
1772
    void *str_allocated[MAX_ARGS];
1773
    void *args[MAX_ARGS];
1774

    
1775
#ifdef DEBUG
1776
    term_printf("command='%s'\n", cmdline);
1777
#endif
1778
    
1779
    /* extract the command name */
1780
    p = cmdline;
1781
    q = cmdname;
1782
    while (isspace(*p))
1783
        p++;
1784
    if (*p == '\0')
1785
        return;
1786
    pstart = p;
1787
    while (*p != '\0' && *p != '/' && !isspace(*p))
1788
        p++;
1789
    len = p - pstart;
1790
    if (len > sizeof(cmdname) - 1)
1791
        len = sizeof(cmdname) - 1;
1792
    memcpy(cmdname, pstart, len);
1793
    cmdname[len] = '\0';
1794
    
1795
    /* find the command */
1796
    for(cmd = term_cmds; cmd->name != NULL; cmd++) {
1797
        if (compare_cmd(cmdname, cmd->name)) 
1798
            goto found;
1799
    }
1800
    term_printf("unknown command: '%s'\n", cmdname);
1801
    return;
1802
 found:
1803

    
1804
    for(i = 0; i < MAX_ARGS; i++)
1805
        str_allocated[i] = NULL;
1806
    
1807
    /* parse the parameters */
1808
    typestr = cmd->args_type;
1809
    nb_args = 0;
1810
    for(;;) {
1811
        c = *typestr;
1812
        if (c == '\0')
1813
            break;
1814
        typestr++;
1815
        switch(c) {
1816
        case 'F':
1817
        case 'B':
1818
        case 's':
1819
            {
1820
                int ret;
1821
                char *str;
1822
                
1823
                while (isspace(*p)) 
1824
                    p++;
1825
                if (*typestr == '?') {
1826
                    typestr++;
1827
                    if (*p == '\0') {
1828
                        /* no optional string: NULL argument */
1829
                        str = NULL;
1830
                        goto add_str;
1831
                    }
1832
                }
1833
                ret = get_str(buf, sizeof(buf), &p);
1834
                if (ret < 0) {
1835
                    switch(c) {
1836
                    case 'F':
1837
                        term_printf("%s: filename expected\n", cmdname);
1838
                        break;
1839
                    case 'B':
1840
                        term_printf("%s: block device name expected\n", cmdname);
1841
                        break;
1842
                    default:
1843
                        term_printf("%s: string expected\n", cmdname);
1844
                        break;
1845
                    }
1846
                    goto fail;
1847
                }
1848
                str = qemu_malloc(strlen(buf) + 1);
1849
                strcpy(str, buf);
1850
                str_allocated[nb_args] = str;
1851
            add_str:
1852
                if (nb_args >= MAX_ARGS) {
1853
                error_args:
1854
                    term_printf("%s: too many arguments\n", cmdname);
1855
                    goto fail;
1856
                }
1857
                args[nb_args++] = str;
1858
            }
1859
            break;
1860
        case '/':
1861
            {
1862
                int count, format, size;
1863
                
1864
                while (isspace(*p))
1865
                    p++;
1866
                if (*p == '/') {
1867
                    /* format found */
1868
                    p++;
1869
                    count = 1;
1870
                    if (isdigit(*p)) {
1871
                        count = 0;
1872
                        while (isdigit(*p)) {
1873
                            count = count * 10 + (*p - '0');
1874
                            p++;
1875
                        }
1876
                    }
1877
                    size = -1;
1878
                    format = -1;
1879
                    for(;;) {
1880
                        switch(*p) {
1881
                        case 'o':
1882
                        case 'd':
1883
                        case 'u':
1884
                        case 'x':
1885
                        case 'i':
1886
                        case 'c':
1887
                            format = *p++;
1888
                            break;
1889
                        case 'b':
1890
                            size = 1;
1891
                            p++;
1892
                            break;
1893
                        case 'h':
1894
                            size = 2;
1895
                            p++;
1896
                            break;
1897
                        case 'w':
1898
                            size = 4;
1899
                            p++;
1900
                            break;
1901
                        case 'g':
1902
                        case 'L':
1903
                            size = 8;
1904
                            p++;
1905
                            break;
1906
                        default:
1907
                            goto next;
1908
                        }
1909
                    }
1910
                next:
1911
                    if (*p != '\0' && !isspace(*p)) {
1912
                        term_printf("invalid char in format: '%c'\n", *p);
1913
                        goto fail;
1914
                    }
1915
                    if (format < 0)
1916
                        format = default_fmt_format;
1917
                    if (format != 'i') {
1918
                        /* for 'i', not specifying a size gives -1 as size */
1919
                        if (size < 0)
1920
                            size = default_fmt_size;
1921
                    }
1922
                    default_fmt_size = size;
1923
                    default_fmt_format = format;
1924
                } else {
1925
                    count = 1;
1926
                    format = default_fmt_format;
1927
                    if (format != 'i') {
1928
                        size = default_fmt_size;
1929
                    } else {
1930
                        size = -1;
1931
                    }
1932
                }
1933
                if (nb_args + 3 > MAX_ARGS)
1934
                    goto error_args;
1935
                args[nb_args++] = (void*)count;
1936
                args[nb_args++] = (void*)format;
1937
                args[nb_args++] = (void*)size;
1938
            }
1939
            break;
1940
        case 'i':
1941
        case 'l':
1942
            {
1943
                target_long val;
1944
                while (isspace(*p)) 
1945
                    p++;
1946
                if (*typestr == '?' || *typestr == '.') {
1947
                    typestr++;
1948
                    if (*typestr == '?') {
1949
                        if (*p == '\0')
1950
                            has_arg = 0;
1951
                        else
1952
                            has_arg = 1;
1953
                    } else {
1954
                        if (*p == '.') {
1955
                            p++;
1956
                            while (isspace(*p)) 
1957
                                p++;
1958
                            has_arg = 1;
1959
                        } else {
1960
                            has_arg = 0;
1961
                        }
1962
                    }
1963
                    if (nb_args >= MAX_ARGS)
1964
                        goto error_args;
1965
                    args[nb_args++] = (void *)has_arg;
1966
                    if (!has_arg) {
1967
                        if (nb_args >= MAX_ARGS)
1968
                            goto error_args;
1969
                        val = -1;
1970
                        goto add_num;
1971
                    }
1972
                }
1973
                if (get_expr(&val, &p))
1974
                    goto fail;
1975
            add_num:
1976
                if (c == 'i') {
1977
                    if (nb_args >= MAX_ARGS)
1978
                        goto error_args;
1979
                    args[nb_args++] = (void *)(int)val;
1980
                } else {
1981
                    if ((nb_args + 1) >= MAX_ARGS)
1982
                        goto error_args;
1983
#if TARGET_LONG_BITS == 64
1984
                    args[nb_args++] = (void *)(int)((val >> 32) & 0xffffffff);
1985
#else
1986
                    args[nb_args++] = (void *)0;
1987
#endif
1988
                    args[nb_args++] = (void *)(int)(val & 0xffffffff);
1989
                }
1990
            }
1991
            break;
1992
        case '-':
1993
            {
1994
                int has_option;
1995
                /* option */
1996
                
1997
                c = *typestr++;
1998
                if (c == '\0')
1999
                    goto bad_type;
2000
                while (isspace(*p)) 
2001
                    p++;
2002
                has_option = 0;
2003
                if (*p == '-') {
2004
                    p++;
2005
                    if (*p != c) {
2006
                        term_printf("%s: unsupported option -%c\n", 
2007
                                    cmdname, *p);
2008
                        goto fail;
2009
                    }
2010
                    p++;
2011
                    has_option = 1;
2012
                }
2013
                if (nb_args >= MAX_ARGS)
2014
                    goto error_args;
2015
                args[nb_args++] = (void *)has_option;
2016
            }
2017
            break;
2018
        default:
2019
        bad_type:
2020
            term_printf("%s: unknown type '%c'\n", cmdname, c);
2021
            goto fail;
2022
        }
2023
    }
2024
    /* check that all arguments were parsed */
2025
    while (isspace(*p))
2026
        p++;
2027
    if (*p != '\0') {
2028
        term_printf("%s: extraneous characters at the end of line\n", 
2029
                    cmdname);
2030
        goto fail;
2031
    }
2032

    
2033
    switch(nb_args) {
2034
    case 0:
2035
        cmd->handler();
2036
        break;
2037
    case 1:
2038
        cmd->handler(args[0]);
2039
        break;
2040
    case 2:
2041
        cmd->handler(args[0], args[1]);
2042
        break;
2043
    case 3:
2044
        cmd->handler(args[0], args[1], args[2]);
2045
        break;
2046
    case 4:
2047
        cmd->handler(args[0], args[1], args[2], args[3]);
2048
        break;
2049
    case 5:
2050
        cmd->handler(args[0], args[1], args[2], args[3], args[4]);
2051
        break;
2052
    case 6:
2053
        cmd->handler(args[0], args[1], args[2], args[3], args[4], args[5]);
2054
        break;
2055
    default:
2056
        term_printf("unsupported number of arguments: %d\n", nb_args);
2057
        goto fail;
2058
    }
2059
 fail:
2060
    for(i = 0; i < MAX_ARGS; i++)
2061
        qemu_free(str_allocated[i]);
2062
    return;
2063
}
2064

    
2065
static void cmd_completion(const char *name, const char *list)
2066
{
2067
    const char *p, *pstart;
2068
    char cmd[128];
2069
    int len;
2070

    
2071
    p = list;
2072
    for(;;) {
2073
        pstart = p;
2074
        p = strchr(p, '|');
2075
        if (!p)
2076
            p = pstart + strlen(pstart);
2077
        len = p - pstart;
2078
        if (len > sizeof(cmd) - 2)
2079
            len = sizeof(cmd) - 2;
2080
        memcpy(cmd, pstart, len);
2081
        cmd[len] = '\0';
2082
        if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
2083
            add_completion(cmd);
2084
        }
2085
        if (*p == '\0')
2086
            break;
2087
        p++;
2088
    }
2089
}
2090

    
2091
static void file_completion(const char *input)
2092
{
2093
    DIR *ffs;
2094
    struct dirent *d;
2095
    char path[1024];
2096
    char file[1024], file_prefix[1024];
2097
    int input_path_len;
2098
    const char *p;
2099

    
2100
    p = strrchr(input, '/'); 
2101
    if (!p) {
2102
        input_path_len = 0;
2103
        pstrcpy(file_prefix, sizeof(file_prefix), input);
2104
        strcpy(path, ".");
2105
    } else {
2106
        input_path_len = p - input + 1;
2107
        memcpy(path, input, input_path_len);
2108
        if (input_path_len > sizeof(path) - 1)
2109
            input_path_len = sizeof(path) - 1;
2110
        path[input_path_len] = '\0';
2111
        pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
2112
    }
2113
#ifdef DEBUG_COMPLETION
2114
    term_printf("input='%s' path='%s' prefix='%s'\n", input, path, file_prefix);
2115
#endif
2116
    ffs = opendir(path);
2117
    if (!ffs)
2118
        return;
2119
    for(;;) {
2120
        struct stat sb;
2121
        d = readdir(ffs);
2122
        if (!d)
2123
            break;
2124
        if (strstart(d->d_name, file_prefix, NULL)) {
2125
            memcpy(file, input, input_path_len);
2126
            strcpy(file + input_path_len, d->d_name);
2127
            /* stat the file to find out if it's a directory.
2128
             * In that case add a slash to speed up typing long paths
2129
             */
2130
            stat(file, &sb);
2131
            if(S_ISDIR(sb.st_mode))
2132
                strcat(file, "/");
2133
            add_completion(file);
2134
        }
2135
    }
2136
    closedir(ffs);
2137
}
2138

    
2139
static void block_completion_it(void *opaque, const char *name)
2140
{
2141
    const char *input = opaque;
2142

    
2143
    if (input[0] == '\0' ||
2144
        !strncmp(name, (char *)input, strlen(input))) {
2145
        add_completion(name);
2146
    }
2147
}
2148

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

    
2157
    p = cmdline;
2158
    nb_args = 0;
2159
    for(;;) {
2160
        while (isspace(*p))
2161
            p++;
2162
        if (*p == '\0')
2163
            break;
2164
        if (nb_args >= MAX_ARGS)
2165
            break;
2166
        ret = get_str(buf, sizeof(buf), &p);
2167
        args[nb_args] = qemu_strdup(buf);
2168
        nb_args++;
2169
        if (ret < 0)
2170
            break;
2171
    }
2172
    *pnb_args = nb_args;
2173
}
2174

    
2175
void readline_find_completion(const char *cmdline)
2176
{
2177
    const char *cmdname;
2178
    char *args[MAX_ARGS];
2179
    int nb_args, i, len;
2180
    const char *ptype, *str;
2181
    term_cmd_t *cmd;
2182
    const KeyDef *key;
2183

    
2184
    parse_cmdline(cmdline, &nb_args, args);
2185
#ifdef DEBUG_COMPLETION
2186
    for(i = 0; i < nb_args; i++) {
2187
        term_printf("arg%d = '%s'\n", i, (char *)args[i]);
2188
    }
2189
#endif
2190

    
2191
    /* if the line ends with a space, it means we want to complete the
2192
       next arg */
2193
    len = strlen(cmdline);
2194
    if (len > 0 && isspace(cmdline[len - 1])) {
2195
        if (nb_args >= MAX_ARGS)
2196
            return;
2197
        args[nb_args++] = qemu_strdup("");
2198
    }
2199
    if (nb_args <= 1) {
2200
        /* command completion */
2201
        if (nb_args == 0)
2202
            cmdname = "";
2203
        else
2204
            cmdname = args[0];
2205
        completion_index = strlen(cmdname);
2206
        for(cmd = term_cmds; cmd->name != NULL; cmd++) {
2207
            cmd_completion(cmdname, cmd->name);
2208
        }
2209
    } else {
2210
        /* find the command */
2211
        for(cmd = term_cmds; cmd->name != NULL; cmd++) {
2212
            if (compare_cmd(args[0], cmd->name))
2213
                goto found;
2214
        }
2215
        return;
2216
    found:
2217
        ptype = cmd->args_type;
2218
        for(i = 0; i < nb_args - 2; i++) {
2219
            if (*ptype != '\0') {
2220
                ptype++;
2221
                while (*ptype == '?')
2222
                    ptype++;
2223
            }
2224
        }
2225
        str = args[nb_args - 1];
2226
        switch(*ptype) {
2227
        case 'F':
2228
            /* file completion */
2229
            completion_index = strlen(str);
2230
            file_completion(str);
2231
            break;
2232
        case 'B':
2233
            /* block device name completion */
2234
            completion_index = strlen(str);
2235
            bdrv_iterate(block_completion_it, (void *)str);
2236
            break;
2237
        case 's':
2238
            /* XXX: more generic ? */
2239
            if (!strcmp(cmd->name, "info")) {
2240
                completion_index = strlen(str);
2241
                for(cmd = info_cmds; cmd->name != NULL; cmd++) {
2242
                    cmd_completion(str, cmd->name);
2243
                }
2244
            } else if (!strcmp(cmd->name, "sendkey")) {
2245
                completion_index = strlen(str);
2246
                for(key = key_defs; key->name != NULL; key++) {
2247
                    cmd_completion(str, key->name);
2248
                }
2249
            }
2250
            break;
2251
        default:
2252
            break;
2253
        }
2254
    }
2255
    for(i = 0; i < nb_args; i++)
2256
        qemu_free(args[i]);
2257
}
2258

    
2259
static int term_can_read(void *opaque)
2260
{
2261
    return 128;
2262
}
2263

    
2264
static void term_read(void *opaque, const uint8_t *buf, int size)
2265
{
2266
    int i;
2267
    for(i = 0; i < size; i++)
2268
        readline_handle_byte(buf[i]);
2269
}
2270

    
2271
static void monitor_start_input(void);
2272

    
2273
static void monitor_handle_command1(void *opaque, const char *cmdline)
2274
{
2275
    monitor_handle_command(cmdline);
2276
    monitor_start_input();
2277
}
2278

    
2279
static void monitor_start_input(void)
2280
{
2281
    readline_start("(qemu) ", 0, monitor_handle_command1, NULL);
2282
}
2283

    
2284
void monitor_init(CharDriverState *hd, int show_banner)
2285
{
2286
    monitor_hd = hd;
2287
    if (show_banner) {
2288
        term_printf("QEMU %s monitor - type 'help' for more information\n",
2289
                    QEMU_VERSION);
2290
    }
2291
    qemu_chr_add_read_handler(hd, term_can_read, term_read, NULL);
2292
    monitor_start_input();
2293
}
2294

    
2295
/* XXX: use threads ? */
2296
/* modal monitor readline */
2297
static int monitor_readline_started;
2298
static char *monitor_readline_buf;
2299
static int monitor_readline_buf_size;
2300

    
2301
static void monitor_readline_cb(void *opaque, const char *input)
2302
{
2303
    pstrcpy(monitor_readline_buf, monitor_readline_buf_size, input);
2304
    monitor_readline_started = 0;
2305
}
2306

    
2307
void monitor_readline(const char *prompt, int is_password,
2308
                      char *buf, int buf_size)
2309
{
2310
    if (is_password) {
2311
        qemu_chr_send_event(monitor_hd, CHR_EVENT_FOCUS);
2312
    }
2313
    readline_start(prompt, is_password, monitor_readline_cb, NULL);
2314
    monitor_readline_buf = buf;
2315
    monitor_readline_buf_size = buf_size;
2316
    monitor_readline_started = 1;
2317
    while (monitor_readline_started) {
2318
        main_loop_wait(10);
2319
    }
2320
}