aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--audio/audio.c6
-rw-r--r--audio/wavcapture.c21
-rw-r--r--block.c66
-rw-r--r--block.h4
-rw-r--r--console.h36
-rw-r--r--disas.c17
-rw-r--r--disas.h8
-rw-r--r--hw/an5206.c5
-rw-r--r--hw/arm_pic.c5
-rw-r--r--hw/etraxfs_pic.c5
-rw-r--r--hw/i8259.c21
-rw-r--r--hw/pc.c9
-rw-r--r--hw/pc.h7
-rw-r--r--hw/pci-hotplug.c51
-rw-r--r--hw/pci.c32
-rw-r--r--hw/pci.h4
-rw-r--r--hw/pcmcia.h4
-rw-r--r--hw/shix.c5
-rw-r--r--hw/slavio_intctl.c20
-rw-r--r--hw/sun4c_intctl.c16
-rw-r--r--hw/sun4m.c8
-rw-r--r--hw/sun4m.h10
-rw-r--r--hw/usb.h2
-rw-r--r--migration-exec.c4
-rw-r--r--migration-tcp.c4
-rw-r--r--migration.c28
-rw-r--r--migration.h10
-rw-r--r--monitor.c752
-rw-r--r--monitor.h25
-rw-r--r--net.c30
-rw-r--r--net.h8
-rw-r--r--qemu-char.c5
-rw-r--r--qemu-char.h4
-rw-r--r--qemu-common.h3
-rw-r--r--qemu-tool.c8
-rw-r--r--readline.c47
-rw-r--r--readline.h20
-rw-r--r--savevm.c83
-rw-r--r--slirp/misc.c4
-rw-r--r--sysemu.h25
-rw-r--r--usb-bsd.c20
-rw-r--r--usb-linux.c35
-rw-r--r--usb-stub.c5
-rw-r--r--vl.c47
-rw-r--r--vnc.c20
45 files changed, 830 insertions, 719 deletions
diff --git a/audio/audio.c b/audio/audio.c
index a2636cb..3c311d7 100644
--- a/audio/audio.c
+++ b/audio/audio.c
@@ -23,7 +23,7 @@
*/
#include "hw/hw.h"
#include "audio.h"
-#include "console.h"
+#include "monitor.h"
#include "qemu-timer.h"
#include "sysemu.h"
@@ -328,10 +328,10 @@ void AUD_vlog (const char *cap, const char *fmt, va_list ap)
{
if (conf.log_to_monitor) {
if (cap) {
- term_printf ("%s: ", cap);
+ monitor_printf(cur_mon, "%s: ", cap);
}
- term_vprintf (fmt, ap);
+ monitor_vprintf(cur_mon, fmt, ap);
}
else {
if (cap) {
diff --git a/audio/wavcapture.c b/audio/wavcapture.c
index 6d1c441..bead458 100644
--- a/audio/wavcapture.c
+++ b/audio/wavcapture.c
@@ -1,5 +1,5 @@
#include "hw/hw.h"
-#include "console.h"
+#include "monitor.h"
#include "audio.h"
typedef struct {
@@ -71,9 +71,9 @@ static void wav_capture_info (void *opaque)
WAVState *wav = opaque;
char *path = wav->path;
- term_printf ("Capturing audio(%d,%d,%d) to %s: %d bytes\n",
- wav->freq, wav->bits, wav->nchannels,
- path ? path : "<not available>", wav->bytes);
+ monitor_printf(cur_mon, "Capturing audio(%d,%d,%d) to %s: %d bytes\n",
+ wav->freq, wav->bits, wav->nchannels,
+ path ? path : "<not available>", wav->bytes);
}
static struct capture_ops wav_capture_ops = {
@@ -84,6 +84,7 @@ static struct capture_ops wav_capture_ops = {
int wav_start_capture (CaptureState *s, const char *path, int freq,
int bits, int nchannels)
{
+ Monitor *mon = cur_mon;
WAVState *wav;
uint8_t hdr[] = {
0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00, 0x57, 0x41, 0x56,
@@ -97,13 +98,13 @@ int wav_start_capture (CaptureState *s, const char *path, int freq,
CaptureVoiceOut *cap;
if (bits != 8 && bits != 16) {
- term_printf ("incorrect bit count %d, must be 8 or 16\n", bits);
+ monitor_printf(mon, "incorrect bit count %d, must be 8 or 16\n", bits);
return -1;
}
if (nchannels != 1 && nchannels != 2) {
- term_printf ("incorrect channel count %d, must be 1 or 2\n",
- nchannels);
+ monitor_printf(mon, "incorrect channel count %d, must be 1 or 2\n",
+ nchannels);
return -1;
}
@@ -131,8 +132,8 @@ int wav_start_capture (CaptureState *s, const char *path, int freq,
wav->f = qemu_fopen (path, "wb");
if (!wav->f) {
- term_printf ("Failed to open wave file `%s'\nReason: %s\n",
- path, strerror (errno));
+ monitor_printf(mon, "Failed to open wave file `%s'\nReason: %s\n",
+ path, strerror (errno));
qemu_free (wav);
return -1;
}
@@ -146,7 +147,7 @@ int wav_start_capture (CaptureState *s, const char *path, int freq,
cap = AUD_add_capture (NULL, &as, &ops, wav);
if (!cap) {
- term_printf ("Failed to add audio capture\n");
+ monitor_printf(mon, "Failed to add audio capture\n");
qemu_free (wav->path);
qemu_fclose (wav->f);
qemu_free (wav);
diff --git a/block.c b/block.c
index 040bbae..81f36b9 100644
--- a/block.c
+++ b/block.c
@@ -28,7 +28,7 @@
#endif
#include "qemu-common.h"
-#include "console.h"
+#include "monitor.h"
#include "block_int.h"
#ifdef _BSD
@@ -1091,66 +1091,66 @@ int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
}
-void bdrv_info(void)
+void bdrv_info(Monitor *mon)
{
BlockDriverState *bs;
for (bs = bdrv_first; bs != NULL; bs = bs->next) {
- term_printf("%s:", bs->device_name);
- term_printf(" type=");
+ monitor_printf(mon, "%s:", bs->device_name);
+ monitor_printf(mon, " type=");
switch(bs->type) {
case BDRV_TYPE_HD:
- term_printf("hd");
+ monitor_printf(mon, "hd");
break;
case BDRV_TYPE_CDROM:
- term_printf("cdrom");
+ monitor_printf(mon, "cdrom");
break;
case BDRV_TYPE_FLOPPY:
- term_printf("floppy");
+ monitor_printf(mon, "floppy");
break;
}
- term_printf(" removable=%d", bs->removable);
+ monitor_printf(mon, " removable=%d", bs->removable);
if (bs->removable) {
- term_printf(" locked=%d", bs->locked);
+ monitor_printf(mon, " locked=%d", bs->locked);
}
if (bs->drv) {
- term_printf(" file=");
- term_print_filename(bs->filename);
+ monitor_printf(mon, " file=");
+ monitor_print_filename(mon, bs->filename);
if (bs->backing_file[0] != '\0') {
- term_printf(" backing_file=");
- term_print_filename(bs->backing_file);
- }
- term_printf(" ro=%d", bs->read_only);
- term_printf(" drv=%s", bs->drv->format_name);
- term_printf(" encrypted=%d", bdrv_is_encrypted(bs));
+ monitor_printf(mon, " backing_file=");
+ monitor_print_filename(mon, bs->backing_file);
+ }
+ monitor_printf(mon, " ro=%d", bs->read_only);
+ monitor_printf(mon, " drv=%s", bs->drv->format_name);
+ monitor_printf(mon, " encrypted=%d", bdrv_is_encrypted(bs));
} else {
- term_printf(" [not inserted]");
+ monitor_printf(mon, " [not inserted]");
}
- term_printf("\n");
+ monitor_printf(mon, "\n");
}
}
/* The "info blockstats" command. */
-void bdrv_info_stats (void)
+void bdrv_info_stats(Monitor *mon)
{
BlockDriverState *bs;
BlockDriverInfo bdi;
for (bs = bdrv_first; bs != NULL; bs = bs->next) {
- term_printf ("%s:"
- " rd_bytes=%" PRIu64
- " wr_bytes=%" PRIu64
- " rd_operations=%" PRIu64
- " wr_operations=%" PRIu64
- ,
- bs->device_name,
- bs->rd_bytes, bs->wr_bytes,
- bs->rd_ops, bs->wr_ops);
+ monitor_printf(mon, "%s:"
+ " rd_bytes=%" PRIu64
+ " wr_bytes=%" PRIu64
+ " rd_operations=%" PRIu64
+ " wr_operations=%" PRIu64
+ ,
+ bs->device_name,
+ bs->rd_bytes, bs->wr_bytes,
+ bs->rd_ops, bs->wr_ops);
if (bdrv_get_info(bs, &bdi) == 0)
- term_printf(" high=%" PRId64
- " bytes_free=%" PRId64,
- bdi.highest_alloc, bdi.num_free_bytes);
- term_printf("\n");
+ monitor_printf(mon, " high=%" PRId64
+ " bytes_free=%" PRId64,
+ bdi.highest_alloc, bdi.num_free_bytes);
+ monitor_printf(mon, "\n");
}
}
diff --git a/block.h b/block.h
index 5c6eaf9..50757a5 100644
--- a/block.h
+++ b/block.h
@@ -56,8 +56,8 @@ typedef struct QEMUSnapshotInfo {
#define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_CACHE_DEF)
-void bdrv_info(void);
-void bdrv_info_stats(void);
+void bdrv_info(Monitor *mon);
+void bdrv_info_stats(Monitor *mon);
void bdrv_init(void);
BlockDriver *bdrv_find_format(const char *format_name);
diff --git a/console.h b/console.h
index dcb49ad..6b72fa5 100644
--- a/console.h
+++ b/console.h
@@ -43,8 +43,8 @@ struct mouse_transform_info_s {
int a[7];
};
-void do_info_mice(void);
-void do_mouse_set(int index);
+void do_info_mice(Monitor *mon);
+void do_mouse_set(Monitor *mon, int index);
/* keysym is a unicode code except for special keys (see QEMU_KEY_xxx
constants) */
@@ -287,39 +287,9 @@ void vnc_display_init(DisplayState *ds);
void vnc_display_close(DisplayState *ds);
int vnc_display_open(DisplayState *ds, const char *display);
int vnc_display_password(DisplayState *ds, const char *password);
-void do_info_vnc(void);
+void do_info_vnc(Monitor *mon);
/* curses.c */
void curses_display_init(DisplayState *ds, int full_screen);
-/* FIXME: term_printf et al should probably go elsewhere so everything
- does not need to include console.h */
-/* monitor.c */
-void monitor_init(CharDriverState *hd, int show_banner);
-void term_puts(const char *str);
-void term_vprintf(const char *fmt, va_list ap);
-void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
-void term_print_filename(const char *filename);
-void term_flush(void);
-void term_print_help(void);
-void monitor_suspend(void);
-void monitor_resume(void);
-
-#include "block.h"
-void monitor_read_bdrv_key_start(BlockDriverState *bs,
- BlockDriverCompletionFunc *completion_cb,
- void *opaque);
-
-/* readline.c */
-typedef void ReadLineFunc(void *opaque, const char *str);
-
-extern int completion_index;
-void add_completion(const char *str);
-void readline_handle_byte(int ch);
-void readline_find_completion(const char *cmdline);
-const char *readline_get_history(unsigned int index);
-void readline_start(const char *prompt, int is_password,
- ReadLineFunc *readline_func, void *opaque);
-void readline_show_prompt(void);
-
#endif
diff --git a/disas.c b/disas.c
index a8cd11c..6bf7592 100644
--- a/disas.c
+++ b/disas.c
@@ -308,8 +308,7 @@ const char *lookup_symbol(target_ulong orig_addr)
#if !defined(CONFIG_USER_ONLY)
-void term_vprintf(const char *fmt, va_list ap);
-void term_printf(const char *fmt, ...);
+#include "monitor.h"
static int monitor_disas_is_physical;
static CPUState *monitor_disas_env;
@@ -330,19 +329,19 @@ static int monitor_fprintf(FILE *stream, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
- term_vprintf(fmt, ap);
+ monitor_vprintf((Monitor *)stream, fmt, ap);
va_end(ap);
return 0;
}
-void monitor_disas(CPUState *env,
+void monitor_disas(Monitor *mon, CPUState *env,
target_ulong pc, int nb_insn, int is_physical, int flags)
{
int count, i;
struct disassemble_info disasm_info;
int (*print_insn)(bfd_vma pc, disassemble_info *info);
- INIT_DISASSEMBLE_INFO(disasm_info, NULL, monitor_fprintf);
+ INIT_DISASSEMBLE_INFO(disasm_info, (FILE *)mon, monitor_fprintf);
monitor_disas_env = env;
monitor_disas_is_physical = is_physical;
@@ -388,15 +387,15 @@ void monitor_disas(CPUState *env,
print_insn = print_insn_little_mips;
#endif
#else
- term_printf("0x" TARGET_FMT_lx
- ": Asm output not supported on this arch\n", pc);
+ monitor_printf(mon, "0x" TARGET_FMT_lx
+ ": Asm output not supported on this arch\n", pc);
return;
#endif
for(i = 0; i < nb_insn; i++) {
- term_printf("0x" TARGET_FMT_lx ": ", pc);
+ monitor_printf(mon, "0x" TARGET_FMT_lx ": ", pc);
count = print_insn(pc, &disasm_info);
- term_printf("\n");
+ monitor_printf(mon, "\n");
if (count < 0)
break;
pc += count;
diff --git a/disas.h b/disas.h
index 13c2aa3..0789b57 100644
--- a/disas.h
+++ b/disas.h
@@ -1,11 +1,17 @@
#ifndef _QEMU_DISAS_H
#define _QEMU_DISAS_H
+#include "qemu-common.h"
+
/* Disassemble this for me please... (debugging). */
void disas(FILE *out, void *code, unsigned long size);
void target_disas(FILE *out, target_ulong code, target_ulong size, int flags);
-void monitor_disas(CPUState *env,
+
+/* The usual mess... FIXME: Remove this condition once dyngen-exec.h is gone */
+#ifndef __DYNGEN_EXEC_H__
+void monitor_disas(Monitor *mon, CPUState *env,
target_ulong pc, int nb_insn, int is_physical, int flags);
+#endif
/* Look up symbol for debugging purpose. Returns "" if unknown. */
const char *lookup_symbol(target_ulong orig_addr);
diff --git a/hw/an5206.c b/hw/an5206.c
index 419d416..83078aa 100644
--- a/hw/an5206.c
+++ b/hw/an5206.c
@@ -7,6 +7,7 @@
*/
#include "hw.h"
+#include "pc.h"
#include "mcf.h"
#include "sysemu.h"
#include "boards.h"
@@ -16,11 +17,11 @@
#define AN5206_RAMBAR_ADDR 0x20000000
/* Stub functions for hardware that doesn't exist. */
-void pic_info(void)
+void pic_info(Monitor *mon)
{
}
-void irq_info(void)
+void irq_info(Monitor *mon)
{
}
diff --git a/hw/arm_pic.c b/hw/arm_pic.c
index 1fe55b7..c9f3cad 100644
--- a/hw/arm_pic.c
+++ b/hw/arm_pic.c
@@ -8,14 +8,15 @@
*/
#include "hw.h"
+#include "pc.h"
#include "arm-misc.h"
/* Stub functions for hardware that doesn't exist. */
-void pic_info(void)
+void pic_info(Monitor *mon)
{
}
-void irq_info(void)
+void irq_info(Monitor *mon)
{
}
diff --git a/hw/etraxfs_pic.c b/hw/etraxfs_pic.c
index 7aa0568..f32b302 100644
--- a/hw/etraxfs_pic.c
+++ b/hw/etraxfs_pic.c
@@ -24,6 +24,7 @@
#include <stdio.h>
#include "hw.h"
+#include "pc.h"
#include "etraxfs.h"
#define D(x)
@@ -135,11 +136,11 @@ static CPUWriteMemoryFunc *pic_write[] = {
&pic_writel,
};
-void pic_info(void)
+void pic_info(Monitor *mon)
{
}
-void irq_info(void)
+void irq_info(Monitor *mon)
{
}
diff --git a/hw/i8259.c b/hw/i8259.c
index 933289b..f813525 100644
--- a/hw/i8259.c
+++ b/hw/i8259.c
@@ -24,7 +24,7 @@
#include "hw.h"
#include "pc.h"
#include "isa.h"
-#include "console.h"
+#include "monitor.h"
/* debug PIC */
//#define DEBUG_PIC
@@ -511,7 +511,7 @@ static void pic_init1(int io_addr, int elcr_addr, PicState *s)
qemu_register_reset(pic_reset, s);
}
-void pic_info(void)
+void pic_info(Monitor *mon)
{
int i;
PicState *s;
@@ -521,26 +521,27 @@ void pic_info(void)
for(i=0;i<2;i++) {
s = &isa_pic->pics[i];
- term_printf("pic%d: irr=%02x imr=%02x isr=%02x hprio=%d irq_base=%02x rr_sel=%d elcr=%02x fnm=%d\n",
- i, s->irr, s->imr, s->isr, s->priority_add,
- s->irq_base, s->read_reg_select, s->elcr,
- s->special_fully_nested_mode);
+ monitor_printf(mon, "pic%d: irr=%02x imr=%02x isr=%02x hprio=%d "
+ "irq_base=%02x rr_sel=%d elcr=%02x fnm=%d\n",
+ i, s->irr, s->imr, s->isr, s->priority_add,
+ s->irq_base, s->read_reg_select, s->elcr,
+ s->special_fully_nested_mode);
}
}
-void irq_info(void)
+void irq_info(Monitor *mon)
{
#ifndef DEBUG_IRQ_COUNT
- term_printf("irq statistic code not compiled.\n");
+ monitor_printf(mon, "irq statistic code not compiled.\n");
#else
int i;
int64_t count;
- term_printf("IRQ statistics:\n");
+ monitor_printf(mon, "IRQ statistics:\n");
for (i = 0; i < 16; i++) {
count = irq_count[i];
if (count > 0)
- term_printf("%2d: %" PRId64 "\n", i, count);
+ monitor_printf(mon, "%2d: %" PRId64 "\n", i, count);
}
#endif
}
diff --git a/hw/pc.c b/hw/pc.c
index 3849390..905d401 100644
--- a/hw/pc.c
+++ b/hw/pc.c
@@ -31,7 +31,7 @@
#include "net.h"
#include "smbus.h"
#include "boards.h"
-#include "console.h"
+#include "monitor.h"
#include "fw_cfg.h"
#include "virtio-blk.h"
#include "virtio-balloon.h"
@@ -208,6 +208,7 @@ static int boot_device2nibble(char boot_device)
and used there as well */
static int pc_boot_set(void *opaque, const char *boot_device)
{
+ Monitor *mon = cur_mon;
#define PC_MAX_BOOT_DEVICES 3
RTCState *s = (RTCState *)opaque;
int nbds, bds[3] = { 0, };
@@ -215,14 +216,14 @@ static int pc_boot_set(void *opaque, const char *boot_device)
nbds = strlen(boot_device);
if (nbds > PC_MAX_BOOT_DEVICES) {
- term_printf("Too many boot devices for PC\n");
+ monitor_printf(mon, "Too many boot devices for PC\n");
return(1);
}
for (i = 0; i < nbds; i++) {
bds[i] = boot_device2nibble(boot_device[i]);
if (bds[i] == 0) {
- term_printf("Invalid boot device for PC: '%c'\n",
- boot_device[i]);
+ monitor_printf(mon, "Invalid boot device for PC: '%c'\n",
+ boot_device[i]);
return(1);
}
}
diff --git a/hw/pc.h b/hw/pc.h
index 5578b3a..7da0c3f 100644
--- a/hw/pc.h
+++ b/hw/pc.h
@@ -1,5 +1,8 @@
#ifndef HW_PC_H
#define HW_PC_H
+
+#include "qemu-common.h"
+
/* PC-style peripherals (also used by other machines). */
/* serial.c */
@@ -34,8 +37,8 @@ void pic_set_alt_irq_func(PicState2 *s, SetIRQFunc *alt_irq_func,
int pic_read_irq(PicState2 *s);
void pic_update_irq(PicState2 *s);
uint32_t pic_intack_read(PicState2 *s);
-void pic_info(void);
-void irq_info(void);
+void pic_info(Monitor *mon);
+void irq_info(Monitor *mon);
/* APIC */
typedef struct IOAPICState IOAPICState;
diff --git a/hw/pci-hotplug.c b/hw/pci-hotplug.c
index 6286764..a01efe0 100644
--- a/hw/pci-hotplug.c
+++ b/hw/pci-hotplug.c
@@ -28,7 +28,7 @@
#include "net.h"
#include "sysemu.h"
#include "pc.h"
-#include "console.h"
+#include "monitor.h"
#include "block_int.h"
#include "virtio-blk.h"
@@ -43,7 +43,7 @@ static PCIDevice *qemu_pci_hot_add_nic(PCIBus *pci_bus, const char *opts)
return pci_nic_init (pci_bus, &nd_table[ret], -1, "rtl8139");
}
-void drive_hot_add(const char *pci_addr, const char *opts)
+void drive_hot_add(Monitor *mon, const char *pci_addr, const char *opts)
{
int dom, pci_bus;
unsigned slot;
@@ -52,13 +52,13 @@ void drive_hot_add(const char *pci_addr, const char *opts)
PCIDevice *dev;
if (pci_read_devaddr(pci_addr, &dom, &pci_bus, &slot)) {
- term_printf("Invalid pci address\n");
+ monitor_printf(mon, "Invalid pci address\n");
return;
}
dev = pci_find_device(pci_bus, slot, 0);
if (!dev) {
- term_printf("no pci device with address %s\n", pci_addr);
+ monitor_printf(mon, "no pci device with address %s\n", pci_addr);
return;
}
@@ -75,16 +75,18 @@ void drive_hot_add(const char *pci_addr, const char *opts)
drives_table[drive_idx].unit);
break;
default:
- term_printf("Can't hot-add drive to type %d\n", type);
+ monitor_printf(mon, "Can't hot-add drive to type %d\n", type);
}
if (success)
- term_printf("OK bus %d, unit %d\n", drives_table[drive_idx].bus,
- drives_table[drive_idx].unit);
+ monitor_printf(mon, "OK bus %d, unit %d\n",
+ drives_table[drive_idx].bus,
+ drives_table[drive_idx].unit);
return;
}
-static PCIDevice *qemu_pci_hot_add_storage(PCIBus *pci_bus, const char *opts)
+static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon, PCIBus *pci_bus,
+ const char *opts)
{
void *opaque = NULL;
int type = -1, drive_idx = -1;
@@ -97,7 +99,7 @@ static PCIDevice *qemu_pci_hot_add_storage(PCIBus *pci_bus, const char *opts)
type = IF_VIRTIO;
}
} else {
- term_printf("no if= specified\n");
+ monitor_printf(mon, "no if= specified\n");
return NULL;
}
@@ -106,7 +108,7 @@ static PCIDevice *qemu_pci_hot_add_storage(PCIBus *pci_bus, const char *opts)
if (drive_idx < 0)
return NULL;
} else if (type == IF_VIRTIO) {
- term_printf("virtio requires a backing file/device.\n");
+ monitor_printf(mon, "virtio requires a backing file/device.\n");
return NULL;
}
@@ -121,13 +123,14 @@ static PCIDevice *qemu_pci_hot_add_storage(PCIBus *pci_bus, const char *opts)
opaque = virtio_blk_init (pci_bus, drives_table[drive_idx].bdrv);
break;
default:
- term_printf ("type %s not a hotpluggable PCI device.\n", buf);
+ monitor_printf(mon, "type %s not a hotpluggable PCI device.\n", buf);
}
return opaque;
}
-void pci_device_hot_add(const char *pci_addr, const char *type, const char *opts)
+void pci_device_hot_add(Monitor *mon, const char *pci_addr, const char *type,
+ const char *opts)
{
PCIDevice *dev = NULL;
PCIBus *pci_bus;
@@ -135,47 +138,47 @@ void pci_device_hot_add(const char *pci_addr, const char *type, const char *opts
unsigned slot;
if (pci_assign_devaddr(pci_addr, &dom, &bus, &slot)) {
- term_printf("Invalid pci address\n");
+ monitor_printf(mon, "Invalid pci address\n");
return;
}
pci_bus = pci_find_bus(bus);
if (!pci_bus) {
- term_printf("Can't find pci_bus %d\n", bus);
+ monitor_printf(mon, "Can't find pci_bus %d\n", bus);
return;
}
if (strcmp(type, "nic") == 0)
dev = qemu_pci_hot_add_nic(pci_bus, opts);
else if (strcmp(type, "storage") == 0)
- dev = qemu_pci_hot_add_storage(pci_bus, opts);
+ dev = qemu_pci_hot_add_storage(mon, pci_bus, opts);
else
- term_printf("invalid type: %s\n", type);
+ monitor_printf(mon, "invalid type: %s\n", type);
if (dev) {
qemu_system_device_hot_add(bus, PCI_SLOT(dev->devfn), 1);
- term_printf("OK domain %d, bus %d, slot %d, function %d\n",
- 0, pci_bus_num(dev->bus), PCI_SLOT(dev->devfn),
- PCI_FUNC(dev->devfn));
+ monitor_printf(mon, "OK domain %d, bus %d, slot %d, function %d\n",
+ 0, pci_bus_num(dev->bus), PCI_SLOT(dev->devfn),
+ PCI_FUNC(dev->devfn));
} else
- term_printf("failed to add %s\n", opts);
+ monitor_printf(mon, "failed to add %s\n", opts);
}
#endif
-void pci_device_hot_remove(const char *pci_addr)
+void pci_device_hot_remove(Monitor *mon, const char *pci_addr)
{
PCIDevice *d;
int dom, bus;
unsigned slot;
if (pci_read_devaddr(pci_addr, &dom, &bus, &slot)) {
- term_printf("Invalid pci address\n");
+ monitor_printf(mon, "Invalid pci address\n");
return;
}
d = pci_find_device(bus, slot, 0);
if (!d) {
- term_printf("slot %d empty\n", slot);
+ monitor_printf(mon, "slot %d empty\n", slot);
return;
}
@@ -199,7 +202,7 @@ void pci_device_hot_remove_success(int pcibus, int slot)
int class_code;
if (!d) {
- term_printf("invalid slot %d\n", slot);
+ monitor_printf(cur_mon, "invalid slot %d\n", slot);
return;
}
diff --git a/hw/pci.c b/hw/pci.c
index 97918a3..18362d3 100644
--- a/hw/pci.c
+++ b/hw/pci.c
@@ -23,7 +23,7 @@
*/
#include "hw.h"
#include "pci.h"
-#include "console.h"
+#include "monitor.h"
#include "net.h"
#include "virtio-net.h"
#include "sysemu.h"
@@ -705,42 +705,44 @@ static const pci_class_desc pci_class_descriptions[] =
static void pci_info_device(PCIDevice *d)
{
+ Monitor *mon = cur_mon;
int i, class;
PCIIORegion *r;
const pci_class_desc *desc;
- term_printf(" Bus %2d, device %3d, function %d:\n",
- d->bus->bus_num, d->devfn >> 3, d->devfn & 7);
+ monitor_printf(mon, " Bus %2d, device %3d, function %d:\n",
+ d->bus->bus_num, d->devfn >> 3, d->devfn & 7);
class = le16_to_cpu(*((uint16_t *)(d->config + PCI_CLASS_DEVICE)));
- term_printf(" ");
+ monitor_printf(mon, " ");
desc = pci_class_descriptions;
while (desc->desc && class != desc->class)
desc++;
if (desc->desc) {
- term_printf("%s", desc->desc);
+ monitor_printf(mon, "%s", desc->desc);
} else {
- term_printf("Class %04x", class);
+ monitor_printf(mon, "Class %04x", class);
}
- term_printf(": PCI device %04x:%04x\n",
+ monitor_printf(mon, ": PCI device %04x:%04x\n",
le16_to_cpu(*((uint16_t *)(d->config + PCI_VENDOR_ID))),
le16_to_cpu(*((uint16_t *)(d->config + PCI_DEVICE_ID))));
if (d->config[PCI_INTERRUPT_PIN] != 0) {
- term_printf(" IRQ %d.\n", d->config[PCI_INTERRUPT_LINE]);
+ monitor_printf(mon, " IRQ %d.\n",
+ d->config[PCI_INTERRUPT_LINE]);
}
if (class == 0x0604) {
- term_printf(" BUS %d.\n", d->config[0x19]);
+ monitor_printf(mon, " BUS %d.\n", d->config[0x19]);
}
for(i = 0;i < PCI_NUM_REGIONS; i++) {
r = &d->io_regions[i];
if (r->size != 0) {
- term_printf(" BAR%d: ", i);
+ monitor_printf(mon, " BAR%d: ", i);
if (r->type & PCI_ADDRESS_SPACE_IO) {
- term_printf("I/O at 0x%04x [0x%04x].\n",
- r->addr, r->addr + r->size - 1);
+ monitor_printf(mon, "I/O at 0x%04x [0x%04x].\n",
+ r->addr, r->addr + r->size - 1);
} else {
- term_printf("32 bit memory at 0x%08x [0x%08x].\n",
- r->addr, r->addr + r->size - 1);
+ monitor_printf(mon, "32 bit memory at 0x%08x [0x%08x].\n",
+ r->addr, r->addr + r->size - 1);
}
}
}
@@ -766,7 +768,7 @@ void pci_for_each_device(int bus_num, void (*fn)(PCIDevice *d))
}
}
-void pci_info(void)
+void pci_info(Monitor *mon)
{
pci_for_each_device(0, pci_info_device);
}
diff --git a/hw/pci.h b/hw/pci.h
index 56381e8..b955f39 100644
--- a/hw/pci.h
+++ b/hw/pci.h
@@ -1,6 +1,8 @@
#ifndef QEMU_PCI_H
#define QEMU_PCI_H
+#include "qemu-common.h"
+
/* PCI includes legacy ISA access. */
#include "isa.h"
@@ -242,7 +244,7 @@ PCIDevice *pci_find_device(int bus_num, int slot, int function);
int pci_read_devaddr(const char *addr, int *domp, int *busp, unsigned *slotp);
int pci_assign_devaddr(const char *addr, int *domp, int *busp, unsigned *slotp);
-void pci_info(void);
+void pci_info(Monitor *mon);
PCIBus *pci_bridge_init(PCIBus *bus, int devfn, uint16_t vid, uint16_t did,
pci_map_irq_fn map_irq, const char *name);
diff --git a/hw/pcmcia.h b/hw/pcmcia.h
index 8f8366c..290a76f 100644
--- a/hw/pcmcia.h
+++ b/hw/pcmcia.h
@@ -1,5 +1,7 @@
/* PCMCIA/Cardbus */
+#include "qemu-common.h"
+
struct pcmcia_socket_s {
qemu_irq irq;
int attached;
@@ -9,7 +11,7 @@ struct pcmcia_socket_s {
void pcmcia_socket_register(struct pcmcia_socket_s *socket);
void pcmcia_socket_unregister(struct pcmcia_socket_s *socket);
-void pcmcia_info(void);
+void pcmcia_info(Monitor *mon);
struct pcmcia_card_s {
void *state;
diff --git a/hw/shix.c b/hw/shix.c
index 0ba02f8..eba44f56 100644
--- a/hw/shix.c
+++ b/hw/shix.c
@@ -28,6 +28,7 @@
More information in target-sh4/README.sh4
*/
#include "hw.h"
+#include "pc.h"
#include "sh.h"
#include "sysemu.h"
#include "boards.h"
@@ -35,12 +36,12 @@
#define BIOS_FILENAME "shix_bios.bin"
#define BIOS_ADDRESS 0xA0000000
-void irq_info(void)
+void irq_info(Monitor *mon)
{
/* XXXXX */
}
-void pic_info(void)
+void pic_info(Monitor *mon)
{
/* XXXXX */
}
diff --git a/hw/slavio_intctl.c b/hw/slavio_intctl.c
index b481b2c..dffa115 100644
--- a/hw/slavio_intctl.c
+++ b/hw/slavio_intctl.c
@@ -23,7 +23,7 @@
*/
#include "hw.h"
#include "sun4m.h"
-#include "console.h"
+#include "monitor.h"
//#define DEBUG_IRQ_COUNT
//#define DEBUG_IRQ
@@ -219,33 +219,33 @@ static CPUWriteMemoryFunc *slavio_intctlm_mem_write[3] = {
slavio_intctlm_mem_writel,
};
-void slavio_pic_info(void *opaque)
+void slavio_pic_info(Monitor *mon, void *opaque)
{
SLAVIO_INTCTLState *s = opaque;
int i;
for (i = 0; i < MAX_CPUS; i++) {
- term_printf("per-cpu %d: pending 0x%08x\n", i,
- s->slaves[i]->intreg_pending);
+ monitor_printf(mon, "per-cpu %d: pending 0x%08x\n", i,
+ s->slaves[i]->intreg_pending);
}
- term_printf("master: pending 0x%08x, disabled 0x%08x\n",
- s->intregm_pending, s->intregm_disabled);
+ monitor_printf(mon, "master: pending 0x%08x, disabled 0x%08x\n",
+ s->intregm_pending, s->intregm_disabled);
}
-void slavio_irq_info(void *opaque)
+void slavio_irq_info(Monitor *mon, void *opaque)
{
#ifndef DEBUG_IRQ_COUNT
- term_printf("irq statistic code not compiled.\n");
+ monitor_printf(mon, "irq statistic code not compiled.\n");
#else
SLAVIO_INTCTLState *s = opaque;
int i;
int64_t count;
- term_printf("IRQ statistics:\n");
+ monitor_printf(mon, "IRQ statistics:\n");
for (i = 0; i < 32; i++) {
count = s->irq_count[i];
if (count > 0)
- term_printf("%2d: %" PRId64 "\n", i, count);
+ monitor_printf(mon, "%2d: %" PRId64 "\n", i, count);
}
#endif
}
diff --git a/hw/sun4c_intctl.c b/hw/sun4c_intctl.c
index 1759157..33df653 100644
--- a/hw/sun4c_intctl.c
+++ b/hw/sun4c_intctl.c
@@ -23,7 +23,7 @@
*/
#include "hw.h"
#include "sun4m.h"
-#include "console.h"
+#include "monitor.h"
//#define DEBUG_IRQ_COUNT
//#define DEBUG_IRQ
@@ -90,26 +90,26 @@ static CPUWriteMemoryFunc *sun4c_intctl_mem_write[3] = {
NULL,
};
-void sun4c_pic_info(void *opaque)
+void sun4c_pic_info(Monitor *mon, void *opaque)
{
Sun4c_INTCTLState *s = opaque;
- term_printf("master: pending 0x%2.2x, enabled 0x%2.2x\n", s->pending,
- s->reg);
+ monitor_printf(mon, "master: pending 0x%2.2x, enabled 0x%2.2x\n",
+ s->pending, s->reg);
}
-void sun4c_irq_info(void *opaque)
+void sun4c_irq_info(Monitor *mon, void *opaque)
{
#ifndef DEBUG_IRQ_COUNT
- term_printf("irq statistic code not compiled.\n");
+ monitor_printf(mon, "irq statistic code not compiled.\n");
#else
Sun4c_INTCTLState *s = opaque;
int64_t count;
- term_printf("IRQ statistics:\n");
+ monitor_printf(mon, "IRQ statistics:\n");
count = s->irq_count[i];
if (count > 0)
- term_printf("%2d: %" PRId64 "\n", i, count);
+ monitor_printf(mon, "%2d: %" PRId64 "\n", i, count);
#endif
}
diff --git a/hw/sun4m.c b/hw/sun4m.c
index bae8803..21667c0 100644
--- a/hw/sun4m.c
+++ b/hw/sun4m.c
@@ -283,16 +283,16 @@ static void nvram_init(m48t59_t *nvram, uint8_t *macaddr, const char *cmdline,
static void *slavio_intctl;
-void pic_info(void)
+void pic_info(Monitor *mon)
{
if (slavio_intctl)
- slavio_pic_info(slavio_intctl);
+ slavio_pic_info(mon, slavio_intctl);
}
-void irq_info(void)
+void irq_info(Monitor *mon)
{
if (slavio_intctl)
- slavio_irq_info(slavio_intctl);
+ slavio_irq_info(mon, slavio_intctl);
}
void cpu_check_irqs(CPUState *env)
diff --git a/hw/sun4m.h b/hw/sun4m.h
index e1fa837..219aaef 100644
--- a/hw/sun4m.h
+++ b/hw/sun4m.h
@@ -1,6 +1,8 @@
#ifndef SUN4M_H
#define SUN4M_H
+#include "qemu-common.h"
+
/* Devices used by sparc32 system. */
/* iommu.c */
@@ -31,8 +33,8 @@ void *slavio_intctl_init(target_phys_addr_t addr, target_phys_addr_t addrg,
const uint32_t *intbit_to_level,
qemu_irq **irq, qemu_irq **cpu_irq,
qemu_irq **parent_irq, unsigned int cputimer);
-void slavio_pic_info(void *opaque);
-void slavio_irq_info(void *opaque);
+void slavio_pic_info(Monitor *mon, void *opaque);
+void slavio_irq_info(Monitor *mon, void *opaque);
/* sbi.c */
void *sbi_init(target_phys_addr_t addr, qemu_irq **irq, qemu_irq **cpu_irq,
@@ -41,8 +43,8 @@ void *sbi_init(target_phys_addr_t addr, qemu_irq **irq, qemu_irq **cpu_irq,
/* sun4c_intctl.c */
void *sun4c_intctl_init(target_phys_addr_t addr, qemu_irq **irq,
qemu_irq *parent_irq);
-void sun4c_pic_info(void *opaque);
-void sun4c_irq_info(void *opaque);
+void sun4c_pic_info(Monitor *mon, void *opaque);
+void sun4c_irq_info(Monitor *mon, void *opaque);
/* slavio_timer.c */
void slavio_timer_init_all(target_phys_addr_t base, qemu_irq master_irq,
diff --git a/hw/usb.h b/hw/usb.h
index a5e0d44..3ecb7d6 100644
--- a/hw/usb.h
+++ b/hw/usb.h
@@ -244,7 +244,7 @@ USBDevice *usb_hub_init(int nb_ports);
/* usb-linux.c */
USBDevice *usb_host_device_open(const char *devname);
int usb_host_device_close(const char *devname);
-void usb_host_info(void);
+void usb_host_info(Monitor *mon);
/* usb-hid.c */
USBDevice *usb_mouse_init(void);
diff --git a/migration-exec.c b/migration-exec.c
index 6ed322a..e2e6e89 100644
--- a/migration-exec.c
+++ b/migration-exec.c
@@ -18,7 +18,7 @@
#include "migration.h"
#include "qemu-char.h"
#include "sysemu.h"
-#include "console.h"
+#include "monitor.h"
#include "buffered_file.h"
#include "block.h"
@@ -94,7 +94,7 @@ MigrationState *exec_start_outgoing_migration(const char *command,
if (s->detach == 1) {
dprintf("detaching from monitor\n");
- monitor_suspend();
+ monitor_suspend(cur_mon);
s->detach = 2;
}
diff --git a/migration-tcp.c b/migration-tcp.c
index 3f5b104..7f67fd9 100644
--- a/migration-tcp.c
+++ b/migration-tcp.c
@@ -16,7 +16,7 @@
#include "migration.h"
#include "qemu-char.h"
#include "sysemu.h"
-#include "console.h"
+#include "monitor.h"
#include "buffered_file.h"
#include "block.h"
@@ -110,7 +110,7 @@ MigrationState *tcp_start_outgoing_migration(const char *host_port,
if (s->detach == 1) {
dprintf("detaching from monitor\n");
- monitor_suspend();
+ monitor_suspend(cur_mon);
s->detach = 2;
}
diff --git a/migration.c b/migration.c
index 0ef777a..cf69bbe 100644
--- a/migration.c
+++ b/migration.c
@@ -13,7 +13,7 @@
#include "qemu-common.h"
#include "migration.h"
-#include "console.h"
+#include "monitor.h"
#include "buffered_file.h"
#include "sysemu.h"
#include "block.h"
@@ -48,7 +48,7 @@ void qemu_start_incoming_migration(const char *uri)
fprintf(stderr, "unknown migration protocol: %s\n", uri);
}
-void do_migrate(int detach, const char *uri)
+void do_migrate(Monitor *mon, int detach, const char *uri)
{
MigrationState *s = NULL;
const char *p;
@@ -60,10 +60,10 @@ void do_migrate(int detach, const char *uri)
s = exec_start_outgoing_migration(p, max_throttle, detach);
#endif
else
- term_printf("unknown migration protocol: %s\n", uri);
+ monitor_printf(mon, "unknown migration protocol: %s\n", uri);
if (s == NULL)
- term_printf("migration failed\n");
+ monitor_printf(mon, "migration failed\n");
else {
if (current_migration)
current_migration->release(current_migration);
@@ -72,7 +72,7 @@ void do_migrate(int detach, const char *uri)
}
}
-void do_migrate_cancel(void)
+void do_migrate_cancel(Monitor *mon)
{
MigrationState *s = current_migration;
@@ -80,7 +80,7 @@ void do_migrate_cancel(void)
s->cancel(s);
}
-void do_migrate_set_speed(const char *value)
+void do_migrate_set_speed(Monitor *mon, const char *value)
{
double d;
char *ptr;
@@ -100,24 +100,24 @@ void do_migrate_set_speed(const char *value)
max_throttle = (uint32_t)d;
}
-void do_info_migrate(void)
+void do_info_migrate(Monitor *mon)
{
MigrationState *s = current_migration;
-
+
if (s) {
- term_printf("Migration status: ");
+ monitor_printf(mon, "Migration status: ");
switch (s->get_status(s)) {
case MIG_STATE_ACTIVE:
- term_printf("active\n");
+ monitor_printf(mon, "active\n");
break;
case MIG_STATE_COMPLETED:
- term_printf("completed\n");
+ monitor_printf(mon, "completed\n");
break;
case MIG_STATE_ERROR:
- term_printf("failed\n");
+ monitor_printf(mon, "failed\n");
break;
case MIG_STATE_CANCELLED:
- term_printf("cancelled\n");
+ monitor_printf(mon, "cancelled\n");
break;
}
}
@@ -146,7 +146,7 @@ void migrate_fd_cleanup(FdMigrationState *s)
/* Don't resume monitor until we've flushed all of the buffers */
if (s->detach == 2) {
- monitor_resume();
+ monitor_resume(cur_mon);
s->detach = 0;
}
diff --git a/migration.h b/migration.h
index d9771ad..32f5a72 100644
--- a/migration.h
+++ b/migration.h
@@ -14,6 +14,8 @@
#ifndef QEMU_MIGRATION_H
#define QEMU_MIGRATION_H
+#include "qemu-common.h"
+
#define MIG_STATE_ERROR -1
#define MIG_STATE_COMPLETED 0
#define MIG_STATE_CANCELLED 1
@@ -47,13 +49,13 @@ struct FdMigrationState
void qemu_start_incoming_migration(const char *uri);
-void do_migrate(int detach, const char *uri);
+void do_migrate(Monitor *mon, int detach, const char *uri);
-void do_migrate_cancel(void);
+void do_migrate_cancel(Monitor *mon);
-void do_migrate_set_speed(const char *value);
+void do_migrate_set_speed(Monitor *mon, const char *value);
-void do_info_migrate(void);
+void do_info_migrate(Monitor *mon);
int exec_start_incoming_migration(const char *host_port);
diff --git a/monitor.c b/monitor.c
index 183c846..b184973 100644
--- a/monitor.c
+++ b/monitor.c
@@ -30,6 +30,8 @@
#include "net.h"
#include "qemu-char.h"
#include "sysemu.h"
+#include "monitor.h"
+#include "readline.h"
#include "console.h"
#include "block.h"
#include "audio/audio.h"
@@ -57,36 +59,39 @@
*
*/
-typedef struct term_cmd_t {
+typedef struct mon_cmd_t {
const char *name;
const char *args_type;
void *handler;
const char *params;
const char *help;
-} term_cmd_t;
+} mon_cmd_t;
#define MAX_MON 4
static CharDriverState *monitor_hd[MAX_MON];
static int hide_banner;
-static const term_cmd_t term_cmds[];
-static const term_cmd_t info_cmds[];
+static const mon_cmd_t mon_cmds[];
+static const mon_cmd_t info_cmds[];
static uint8_t term_outbuf[1024];
static int term_outbuf_index;
static BlockDriverCompletionFunc *password_completion_cb;
static void *password_opaque;
+Monitor *cur_mon;
+
static void monitor_start_input(void);
static CPUState *mon_cpu = NULL;
-static void monitor_read_password(ReadLineFunc *readline_func, void *opaque)
+static void monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
+ void *opaque)
{
readline_start("Password: ", 1, readline_func, opaque);
}
-void term_flush(void)
+void monitor_flush(Monitor *mon)
{
int i;
if (term_outbuf_index > 0) {
@@ -98,7 +103,7 @@ void term_flush(void)
}
/* flush at every end of line or if the buffer is full */
-void term_puts(const char *str)
+static void monitor_puts(Monitor *mon, const char *str)
{
char c;
for(;;) {
@@ -110,26 +115,26 @@ void term_puts(const char *str)
term_outbuf[term_outbuf_index++] = c;
if (term_outbuf_index >= (sizeof(term_outbuf) - 1) ||
c == '\n')
- term_flush();
+ monitor_flush(mon);
}
}
-void term_vprintf(const char *fmt, va_list ap)
+void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
{
char buf[4096];
vsnprintf(buf, sizeof(buf), fmt, ap);
- term_puts(buf);
+ monitor_puts(mon, buf);
}
-void term_printf(const char *fmt, ...)
+void monitor_printf(Monitor *mon, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
- term_vprintf(fmt, ap);
+ monitor_vprintf(mon, fmt, ap);
va_end(ap);
}
-void term_print_filename(const char *filename)
+void monitor_print_filename(Monitor *mon, const char *filename)
{
int i;
@@ -138,19 +143,19 @@ void term_print_filename(const char *filename)
case ' ':
case '"':
case '\\':
- term_printf("\\%c", filename[i]);
+ monitor_printf(mon, "\\%c", filename[i]);
break;
case '\t':
- term_printf("\\t");
+ monitor_printf(mon, "\\t");
break;
case '\r':
- term_printf("\\r");
+ monitor_printf(mon, "\\r");
break;
case '\n':
- term_printf("\\n");
+ monitor_printf(mon, "\\n");
break;
default:
- term_printf("%c", filename[i]);
+ monitor_printf(mon, "%c", filename[i]);
break;
}
}
@@ -160,7 +165,7 @@ static int monitor_fprintf(FILE *stream, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
- term_vprintf(fmt, ap);
+ monitor_vprintf((Monitor *)stream, fmt, ap);
va_end(ap);
return 0;
}
@@ -185,39 +190,36 @@ static int compare_cmd(const char *name, const char *list)
return 0;
}
-static void help_cmd1(const term_cmd_t *cmds, const char *prefix, const char *name)
+static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
+ const char *prefix, const char *name)
{
- const term_cmd_t *cmd;
+ const mon_cmd_t *cmd;
for(cmd = cmds; cmd->name != NULL; cmd++) {
if (!name || !strcmp(name, cmd->name))
- term_printf("%s%s %s -- %s\n", prefix, cmd->name, cmd->params, cmd->help);
+ monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
+ cmd->params, cmd->help);
}
}
-static void help_cmd(const char *name)
+static void help_cmd(Monitor *mon, const char *name)
{
if (name && !strcmp(name, "info")) {
- help_cmd1(info_cmds, "info ", NULL);
+ help_cmd_dump(mon, info_cmds, "info ", NULL);
} else {
- help_cmd1(term_cmds, "", name);
+ help_cmd_dump(mon, mon_cmds, "", name);
if (name && !strcmp(name, "log")) {
const CPULogItem *item;
- term_printf("Log items (comma separated):\n");
- term_printf("%-10s %s\n", "none", "remove all logs");
+ monitor_printf(mon, "Log items (comma separated):\n");
+ monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
for(item = cpu_log_items; item->mask != 0; item++) {
- term_printf("%-10s %s\n", item->name, item->help);
+ monitor_printf(mon, "%-10s %s\n", item->name, item->help);
}
}
}
}
-static void do_help(const char *name)
-{
- help_cmd(name);
-}
-
-static void do_commit(const char *device)
+static void do_commit(Monitor *mon, const char *device)
{
int i, all_devices;
@@ -229,10 +231,10 @@ static void do_commit(const char *device)
}
}
-static void do_info(const char *item)
+static void do_info(Monitor *mon, const char *item)
{
- const term_cmd_t *cmd;
- void (*handler)(void);
+ const mon_cmd_t *cmd;
+ void (*handler)(Monitor *);
if (!item)
goto help;
@@ -241,48 +243,39 @@ static void do_info(const char *item)
goto found;
}
help:
- help_cmd("info");
+ help_cmd(mon, "info");
return;
found:
handler = cmd->handler;
- handler();
+ handler(mon);
}
-static void do_info_version(void)
+static void do_info_version(Monitor *mon)
{
- term_printf("%s\n", QEMU_VERSION);
+ monitor_printf(mon, "%s\n", QEMU_VERSION);
}
-static void do_info_name(void)
+static void do_info_name(Monitor *mon)
{
if (qemu_name)
- term_printf("%s\n", qemu_name);
+ monitor_printf(mon, "%s\n", qemu_name);
}
#if defined(TARGET_I386)
-static void do_info_hpet(void)
+static void do_info_hpet(Monitor *mon)
{
- term_printf("HPET is %s by QEMU\n", (no_hpet) ? "disabled" : "enabled");
+ monitor_printf(mon, "HPET is %s by QEMU\n",
+ (no_hpet) ? "disabled" : "enabled");
}
#endif
-static void do_info_uuid(void)
-{
- term_printf(UUID_FMT "\n", qemu_uuid[0], qemu_uuid[1], qemu_uuid[2],
- qemu_uuid[3], qemu_uuid[4], qemu_uuid[5], qemu_uuid[6],
- qemu_uuid[7], qemu_uuid[8], qemu_uuid[9], qemu_uuid[10],
- qemu_uuid[11], qemu_uuid[12], qemu_uuid[13], qemu_uuid[14],
- qemu_uuid[15]);
-}
-
-static void do_info_block(void)
-{
- bdrv_info();
-}
-
-static void do_info_blockstats(void)
+static void do_info_uuid(Monitor *mon)
{
- bdrv_info_stats();
+ monitor_printf(mon, UUID_FMT "\n", qemu_uuid[0], qemu_uuid[1],
+ qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
+ qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
+ qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
+ qemu_uuid[14], qemu_uuid[15]);
}
/* get the current CPU defined by the user */
@@ -307,22 +300,22 @@ static CPUState *mon_get_cpu(void)
return mon_cpu;
}
-static void do_info_registers(void)
+static void do_info_registers(Monitor *mon)
{
CPUState *env;
env = mon_get_cpu();
if (!env)
return;
#ifdef TARGET_I386
- cpu_dump_state(env, NULL, monitor_fprintf,
+ cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
X86_DUMP_FPU);
#else
- cpu_dump_state(env, NULL, monitor_fprintf,
+ cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
0);
#endif
}
-static void do_info_cpus(void)
+static void do_info_cpus(Monitor *mon)
{
CPUState *env;
@@ -330,36 +323,38 @@ static void do_info_cpus(void)
mon_get_cpu();
for(env = first_cpu; env != NULL; env = env->next_cpu) {
- term_printf("%c CPU #%d:",
- (env == mon_cpu) ? '*' : ' ',
- env->cpu_index);
+ monitor_printf(mon, "%c CPU #%d:",
+ (env == mon_cpu) ? '*' : ' ',
+ env->cpu_index);
#if defined(TARGET_I386)
- term_printf(" pc=0x" TARGET_FMT_lx, env->eip + env->segs[R_CS].base);
+ monitor_printf(mon, " pc=0x" TARGET_FMT_lx,
+ env->eip + env->segs[R_CS].base);
#elif defined(TARGET_PPC)
- term_printf(" nip=0x" TARGET_FMT_lx, env->nip);
+ monitor_printf(mon, " nip=0x" TARGET_FMT_lx, env->nip);
#elif defined(TARGET_SPARC)
- term_printf(" pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx, env->pc, env->npc);
+ monitor_printf(mon, " pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx,
+ env->pc, env->npc);
#elif defined(TARGET_MIPS)
- term_printf(" PC=0x" TARGET_FMT_lx, env->active_tc.PC);
+ monitor_printf(mon, " PC=0x" TARGET_FMT_lx, env->active_tc.PC);
#endif
if (env->halted)
- term_printf(" (halted)");
- term_printf("\n");
+ monitor_printf(mon, " (halted)");
+ monitor_printf(mon, "\n");
}
}
-static void do_cpu_set(int index)
+static void do_cpu_set(Monitor *mon, int index)
{
if (mon_set_cpu(index) < 0)
- term_printf("Invalid CPU index\n");
+ monitor_printf(mon, "Invalid CPU index\n");
}
-static void do_info_jit(void)
+static void do_info_jit(Monitor *mon)
{
- dump_exec_info(NULL, monitor_fprintf);
+ dump_exec_info((FILE *)mon, monitor_fprintf);
}
-static void do_info_history (void)
+static void do_info_history(Monitor *mon)
{
int i;
const char *str;
@@ -369,37 +364,37 @@ static void do_info_history (void)
str = readline_get_history(i);
if (!str)
break;
- term_printf("%d: '%s'\n", i, str);
+ monitor_printf(mon, "%d: '%s'\n", i, str);
i++;
}
}
#if defined(TARGET_PPC)
/* XXX: not implemented in other targets */
-static void do_info_cpu_stats (void)
+static void do_info_cpu_stats(Monitor *mon)
{
CPUState *env;
env = mon_get_cpu();
- cpu_dump_statistics(env, NULL, &monitor_fprintf, 0);
+ cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
}
#endif
-static void do_quit(void)
+static void do_quit(Monitor *mon)
{
exit(0);
}
-static int eject_device(BlockDriverState *bs, int force)
+static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
{
if (bdrv_is_inserted(bs)) {
if (!force) {
if (!bdrv_is_removable(bs)) {
- term_printf("device is not removable\n");
+ monitor_printf(mon, "device is not removable\n");
return -1;
}
if (bdrv_is_locked(bs)) {
- term_printf("device is locked\n");
+ monitor_printf(mon, "device is locked\n");
return -1;
}
}
@@ -408,50 +403,52 @@ static int eject_device(BlockDriverState *bs, int force)
return 0;
}
-static void do_eject(int force, const char *filename)
+static void do_eject(Monitor *mon, int force, const char *filename)
{
BlockDriverState *bs;
bs = bdrv_find(filename);
if (!bs) {
- term_printf("device not found\n");
+ monitor_printf(mon, "device not found\n");
return;
}
- eject_device(bs, force);
+ eject_device(mon, bs, force);
}
-static void do_change_block(const char *device, const char *filename, const char *fmt)
+static void do_change_block(Monitor *mon, const char *device,
+ const char *filename, const char *fmt)
{
BlockDriverState *bs;
BlockDriver *drv = NULL;
bs = bdrv_find(device);
if (!bs) {
- term_printf("device not found\n");
+ monitor_printf(mon, "device not found\n");
return;
}
if (fmt) {
drv = bdrv_find_format(fmt);
if (!drv) {
- term_printf("invalid format %s\n", fmt);
+ monitor_printf(mon, "invalid format %s\n", fmt);
return;
}
}
- if (eject_device(bs, 0) < 0)
+ if (eject_device(mon, bs, 0) < 0)
return;
bdrv_open2(bs, filename, 0, drv);
- monitor_read_bdrv_key_start(bs, NULL, NULL);
+ monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
}
-static void change_vnc_password_cb(void *opaque, const char *password)
+static void change_vnc_password_cb(Monitor *mon, const char *password,
+ void *opaque)
{
if (vnc_display_password(NULL, password) < 0)
- term_printf("could not set VNC server password\n");
+ monitor_printf(mon, "could not set VNC server password\n");
monitor_start_input();
}
-static void do_change_vnc(const char *target, const char *arg)
+static void do_change_vnc(Monitor *mon, const char *target, const char *arg)
{
if (strcmp(target, "passwd") == 0 ||
strcmp(target, "password") == 0) {
@@ -459,36 +456,37 @@ static void do_change_vnc(const char *target, const char *arg)
char password[9];
strncpy(password, arg, sizeof(password));
password[sizeof(password) - 1] = '\0';
- change_vnc_password_cb(NULL, password);
+ change_vnc_password_cb(mon, password, NULL);
} else {
- monitor_read_password(change_vnc_password_cb, NULL);
+ monitor_read_password(mon, change_vnc_password_cb, NULL);
}
} else {
if (vnc_display_open(NULL, target) < 0)
- term_printf("could not start VNC server on %s\n", target);
+ monitor_printf(mon, "could not start VNC server on %s\n", target);
}
}
-static void do_change(const char *device, const char *target, const char *arg)
+static void do_change(Monitor *mon, const char *device, const char *target,
+ const char *arg)
{
if (strcmp(device, "vnc") == 0) {
- do_change_vnc(target, arg);
+ do_change_vnc(mon, target, arg);
} else {
- do_change_block(device, target, arg);
+ do_change_block(mon, device, target, arg);
}
}
-static void do_screen_dump(const char *filename)
+static void do_screen_dump(Monitor *mon, const char *filename)
{
vga_hw_screen_dump(filename);
}
-static void do_logfile(const char *filename)
+static void do_logfile(Monitor *mon, const char *filename)
{
cpu_set_log_filename(filename);
}
-static void do_log(const char *items)
+static void do_log(Monitor *mon, const char *items)
{
int mask;
@@ -497,88 +495,97 @@ static void do_log(const char *items)
} else {
mask = cpu_str_to_log_mask(items);
if (!mask) {
- help_cmd("log");
+ help_cmd(mon, "log");
return;
}
}
cpu_set_log(mask);
}
-static void do_stop(void)
+static void do_stop(Monitor *mon)
{
vm_stop(EXCP_INTERRUPT);
}
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
-static void do_cont(void)
+struct bdrv_iterate_context {
+ Monitor *mon;
+ int err;
+};
+
+static void do_cont(Monitor *mon)
{
- int err = 0;
+ struct bdrv_iterate_context context = { mon, 0 };
- bdrv_iterate(encrypted_bdrv_it, &err);
+ bdrv_iterate(encrypted_bdrv_it, &context);
/* only resume the vm if all keys are set and valid */
- if (!err)
+ if (!context.err)
vm_start();
}
static void bdrv_key_cb(void *opaque, int err)
{
+ Monitor *mon = opaque;
+
/* another key was set successfully, retry to continue */
if (!err)
- do_cont();
+ do_cont(mon);
}
static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
{
- int *err = opaque;
+ struct bdrv_iterate_context *context = opaque;
- if (!*err && bdrv_key_required(bs)) {
- *err = -EBUSY;
- monitor_read_bdrv_key_start(bs, bdrv_key_cb, NULL);
+ if (!context->err && bdrv_key_required(bs)) {
+ context->err = -EBUSY;
+ monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
+ context->mon);
}
}
#ifdef CONFIG_GDBSTUB
-static void do_gdbserver(const char *port)
+static void do_gdbserver(Monitor *mon, const char *port)
{
if (!port)
port = DEFAULT_GDBSTUB_PORT;
if (gdbserver_start(port) < 0) {
- qemu_printf("Could not open gdbserver socket on port '%s'\n", port);
+ monitor_printf(mon, "Could not open gdbserver socket on port '%s'\n",
+ port);
} else {
- qemu_printf("Waiting gdb connection on port '%s'\n", port);
+ monitor_printf(mon, "Waiting gdb connection on port '%s'\n", port);
}
}
#endif
-static void term_printc(int c)
+static void monitor_printc(Monitor *mon, int c)
{
- term_printf("'");
+ monitor_printf(mon, "'");
switch(c) {
case '\'':
- term_printf("\\'");
+ monitor_printf(mon, "\\'");
break;
case '\\':
- term_printf("\\\\");
+ monitor_printf(mon, "\\\\");
break;
case '\n':
- term_printf("\\n");
+ monitor_printf(mon, "\\n");
break;
case '\r':
- term_printf("\\r");
+ monitor_printf(mon, "\\r");
break;
default:
if (c >= 32 && c <= 126) {
- term_printf("%c", c);
+ monitor_printf(mon, "%c", c);
} else {
- term_printf("\\x%02x", c);
+ monitor_printf(mon, "\\x%02x", c);
}
break;
}
- term_printf("'");
+ monitor_printf(mon, "'");
}
-static void memory_dump(int count, int format, int wsize,
+static void memory_dump(Monitor *mon, int count, int format, int wsize,
target_phys_addr_t addr, int is_physical)
{
CPUState *env;
@@ -612,7 +619,7 @@ static void memory_dump(int count, int format, int wsize,
}
}
#endif
- monitor_disas(env, addr, count, is_physical, flags);
+ monitor_disas(mon, env, addr, count, is_physical, flags);
return;
}
@@ -643,9 +650,9 @@ static void memory_dump(int count, int format, int wsize,
while (len > 0) {
if (is_physical)
- term_printf(TARGET_FMT_plx ":", addr);
+ monitor_printf(mon, TARGET_FMT_plx ":", addr);
else
- term_printf(TARGET_FMT_lx ":", (target_ulong)addr);
+ monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
l = len;
if (l > line_size)
l = line_size;
@@ -656,7 +663,7 @@ static void memory_dump(int count, int format, int wsize,
if (!env)
break;
if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
- term_printf(" Cannot access memory\n");
+ monitor_printf(mon, " Cannot access memory\n");
break;
}
}
@@ -677,27 +684,27 @@ static void memory_dump(int count, int format, int wsize,
v = ldq_raw(buf + i);
break;
}
- term_printf(" ");
+ monitor_printf(mon, " ");
switch(format) {
case 'o':
- term_printf("%#*" PRIo64, max_digits, v);
+ monitor_printf(mon, "%#*" PRIo64, max_digits, v);
break;
case 'x':
- term_printf("0x%0*" PRIx64, max_digits, v);
+ monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
break;
case 'u':
- term_printf("%*" PRIu64, max_digits, v);
+ monitor_printf(mon, "%*" PRIu64, max_digits, v);
break;
case 'd':
- term_printf("%*" PRId64, max_digits, v);
+ monitor_printf(mon, "%*" PRId64, max_digits, v);
break;
case 'c':
- term_printc(v);
+ monitor_printc(mon, v);
break;
}
i += wsize;
}
- term_printf("\n");
+ monitor_printf(mon, "\n");
addr += l;
len -= l;
}
@@ -709,11 +716,11 @@ static void memory_dump(int count, int format, int wsize,
#define GET_TLONG(h, l) (l)
#endif
-static void do_memory_dump(int count, int format, int size,
+static void do_memory_dump(Monitor *mon, int count, int format, int size,
uint32_t addrh, uint32_t addrl)
{
target_long addr = GET_TLONG(addrh, addrl);
- memory_dump(count, format, size, addr, 0);
+ memory_dump(mon, count, format, size, addr, 0);
}
#if TARGET_PHYS_ADDR_BITS > 32
@@ -722,60 +729,61 @@ static void do_memory_dump(int count, int format, int size,
#define GET_TPHYSADDR(h, l) (l)
#endif
-static void do_physical_memory_dump(int count, int format, int size,
- uint32_t addrh, uint32_t addrl)
+static void do_physical_memory_dump(Monitor *mon, int count, int format,
+ int size, uint32_t addrh, uint32_t addrl)
{
target_phys_addr_t addr = GET_TPHYSADDR(addrh, addrl);
- memory_dump(count, format, size, addr, 1);
+ memory_dump(mon, count, format, size, addr, 1);
}
-static void do_print(int count, int format, int size, unsigned int valh, unsigned int vall)
+static void do_print(Monitor *mon, int count, int format, int size,
+ unsigned int valh, unsigned int vall)
{
target_phys_addr_t val = GET_TPHYSADDR(valh, vall);
#if TARGET_PHYS_ADDR_BITS == 32
switch(format) {
case 'o':
- term_printf("%#o", val);
+ monitor_printf(mon, "%#o", val);
break;
case 'x':
- term_printf("%#x", val);
+ monitor_printf(mon, "%#x", val);
break;
case 'u':
- term_printf("%u", val);
+ monitor_printf(mon, "%u", val);
break;
default:
case 'd':
- term_printf("%d", val);
+ monitor_printf(mon, "%d", val);
break;
case 'c':
- term_printc(val);
+ monitor_printc(mon, val);
break;
}
#else
switch(format) {
case 'o':
- term_printf("%#" PRIo64, val);
+ monitor_printf(mon, "%#" PRIo64, val);
break;
case 'x':
- term_printf("%#" PRIx64, val);
+ monitor_printf(mon, "%#" PRIx64, val);
break;
case 'u':
- term_printf("%" PRIu64, val);
+ monitor_printf(mon, "%" PRIu64, val);
break;
default:
case 'd':
- term_printf("%" PRId64, val);
+ monitor_printf(mon, "%" PRId64, val);
break;
case 'c':
- term_printc(val);
+ monitor_printc(mon, val);
break;
}
#endif
- term_printf("\n");
+ monitor_printf(mon, "\n");
}
-static void do_memory_save(unsigned int valh, unsigned int vall,
+static void do_memory_save(Monitor *mon, unsigned int valh, unsigned int vall,
uint32_t size, const char *filename)
{
FILE *f;
@@ -790,7 +798,7 @@ static void do_memory_save(unsigned int valh, unsigned int vall,
f = fopen(filename, "wb");
if (!f) {
- term_printf("could not open '%s'\n", filename);
+ monitor_printf(mon, "could not open '%s'\n", filename);
return;
}
while (size != 0) {
@@ -805,8 +813,9 @@ static void do_memory_save(unsigned int valh, unsigned int vall,
fclose(f);
}
-static void do_physical_memory_save(unsigned int valh, unsigned int vall,
- uint32_t size, const char *filename)
+static void do_physical_memory_save(Monitor *mon, unsigned int valh,
+ unsigned int vall, uint32_t size,
+ const char *filename)
{
FILE *f;
uint32_t l;
@@ -815,7 +824,7 @@ static void do_physical_memory_save(unsigned int valh, unsigned int vall,
f = fopen(filename, "wb");
if (!f) {
- term_printf("could not open '%s'\n", filename);
+ monitor_printf(mon, "could not open '%s'\n", filename);
return;
}
while (size != 0) {
@@ -831,7 +840,7 @@ static void do_physical_memory_save(unsigned int valh, unsigned int vall,
fclose(f);
}
-static void do_sum(uint32_t start, uint32_t size)
+static void do_sum(Monitor *mon, uint32_t start, uint32_t size)
{
uint32_t addr;
uint8_t buf[1];
@@ -844,7 +853,7 @@ static void do_sum(uint32_t start, uint32_t size)
sum = (sum >> 1) | (sum << 15);
sum += buf[0];
}
- term_printf("%05d\n", sum);
+ monitor_printf(mon, "%05d\n", sum);
}
typedef struct {
@@ -1027,7 +1036,8 @@ static void release_keys(void *opaque)
}
}
-static void do_sendkey(const char *string, int has_hold_time, int hold_time)
+static void do_sendkey(Monitor *mon, const char *string, int has_hold_time,
+ int hold_time)
{
char keyname_buf[16];
char *separator;
@@ -1046,17 +1056,17 @@ static void do_sendkey(const char *string, int has_hold_time, int hold_time)
if (keyname_len > 0) {
pstrcpy(keyname_buf, sizeof(keyname_buf), string);
if (keyname_len > sizeof(keyname_buf) - 1) {
- term_printf("invalid key: '%s...'\n", keyname_buf);
+ monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
return;
}
if (i == MAX_KEYCODES) {
- term_printf("too many keys\n");
+ monitor_printf(mon, "too many keys\n");
return;
}
keyname_buf[keyname_len] = 0;
keycode = get_keycode(keyname_buf);
if (keycode < 0) {
- term_printf("unknown key: '%s'\n", keyname_buf);
+ monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
return;
}
keycodes[i++] = keycode;
@@ -1080,7 +1090,7 @@ static void do_sendkey(const char *string, int has_hold_time, int hold_time)
static int mouse_button_state;
-static void do_mouse_move(const char *dx_str, const char *dy_str,
+static void do_mouse_move(Monitor *mon, const char *dx_str, const char *dy_str,
const char *dz_str)
{
int dx, dy, dz;
@@ -1092,13 +1102,14 @@ static void do_mouse_move(const char *dx_str, const char *dy_str,
kbd_mouse_event(dx, dy, dz, mouse_button_state);
}
-static void do_mouse_button(int button_state)
+static void do_mouse_button(Monitor *mon, int button_state)
{
mouse_button_state = button_state;
kbd_mouse_event(0, 0, 0, mouse_button_state);
}
-static void do_ioport_read(int count, int format, int size, int addr, int has_index, int index)
+static void do_ioport_read(Monitor *mon, int count, int format, int size,
+ int addr, int has_index, int index)
{
uint32_t val;
int suffix;
@@ -1124,8 +1135,8 @@ static void do_ioport_read(int count, int format, int size, int addr, int has_in
suffix = 'l';
break;
}
- term_printf("port%c[0x%04x] = %#0*x\n",
- suffix, addr, size * 2, val);
+ monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
+ suffix, addr, size * 2, val);
}
/* boot_set handler */
@@ -1138,48 +1149,51 @@ void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
boot_opaque = opaque;
}
-static void do_boot_set(const char *bootdevice)
+static void do_boot_set(Monitor *mon, const char *bootdevice)
{
int res;
if (qemu_boot_set_handler) {
res = qemu_boot_set_handler(boot_opaque, bootdevice);
if (res == 0)
- term_printf("boot device list now set to %s\n", bootdevice);
+ monitor_printf(mon, "boot device list now set to %s\n",
+ bootdevice);
else
- term_printf("setting boot device list failed with error %i\n", res);
+ monitor_printf(mon, "setting boot device list failed with "
+ "error %i\n", res);
} else {
- term_printf("no function defined to set boot device list for this architecture\n");
+ monitor_printf(mon, "no function defined to set boot device list for "
+ "this architecture\n");
}
}
-static void do_system_reset(void)
+static void do_system_reset(Monitor *mon)
{
qemu_system_reset_request();
}
-static void do_system_powerdown(void)
+static void do_system_powerdown(Monitor *mon)
{
qemu_system_powerdown_request();
}
#if defined(TARGET_I386)
-static void print_pte(uint32_t addr, uint32_t pte, uint32_t mask)
+static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
{
- term_printf("%08x: %08x %c%c%c%c%c%c%c%c\n",
- addr,
- pte & mask,
- pte & PG_GLOBAL_MASK ? 'G' : '-',
- pte & PG_PSE_MASK ? 'P' : '-',
- pte & PG_DIRTY_MASK ? 'D' : '-',
- pte & PG_ACCESSED_MASK ? 'A' : '-',
- pte & PG_PCD_MASK ? 'C' : '-',
- pte & PG_PWT_MASK ? 'T' : '-',
- pte & PG_USER_MASK ? 'U' : '-',
- pte & PG_RW_MASK ? 'W' : '-');
+ monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
+ addr,
+ pte & mask,
+ pte & PG_GLOBAL_MASK ? 'G' : '-',
+ pte & PG_PSE_MASK ? 'P' : '-',
+ pte & PG_DIRTY_MASK ? 'D' : '-',
+ pte & PG_ACCESSED_MASK ? 'A' : '-',
+ pte & PG_PCD_MASK ? 'C' : '-',
+ pte & PG_PWT_MASK ? 'T' : '-',
+ pte & PG_USER_MASK ? 'U' : '-',
+ pte & PG_RW_MASK ? 'W' : '-');
}
-static void tlb_info(void)
+static void tlb_info(Monitor *mon)
{
CPUState *env;
int l1, l2;
@@ -1190,7 +1204,7 @@ static void tlb_info(void)
return;
if (!(env->cr[0] & CR0_PG_MASK)) {
- term_printf("PG disabled\n");
+ monitor_printf(mon, "PG disabled\n");
return;
}
pgd = env->cr[3] & ~0xfff;
@@ -1199,14 +1213,14 @@ static void tlb_info(void)
pde = le32_to_cpu(pde);
if (pde & PG_PRESENT_MASK) {
if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
- print_pte((l1 << 22), pde, ~((1 << 20) - 1));
+ print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
} else {
for(l2 = 0; l2 < 1024; l2++) {
cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
(uint8_t *)&pte, 4);
pte = le32_to_cpu(pte);
if (pte & PG_PRESENT_MASK) {
- print_pte((l1 << 22) + (l2 << 12),
+ print_pte(mon, (l1 << 22) + (l2 << 12),
pte & ~PG_PSE_MASK,
~0xfff);
}
@@ -1216,18 +1230,18 @@ static void tlb_info(void)
}
}
-static void mem_print(uint32_t *pstart, int *plast_prot,
+static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
uint32_t end, int prot)
{
int prot1;
prot1 = *plast_prot;
if (prot != prot1) {
if (*pstart != -1) {
- term_printf("%08x-%08x %08x %c%c%c\n",
- *pstart, end, end - *pstart,
- prot1 & PG_USER_MASK ? 'u' : '-',
- 'r',
- prot1 & PG_RW_MASK ? 'w' : '-');
+ monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
+ *pstart, end, end - *pstart,
+ prot1 & PG_USER_MASK ? 'u' : '-',
+ 'r',
+ prot1 & PG_RW_MASK ? 'w' : '-');
}
if (prot != 0)
*pstart = end;
@@ -1237,7 +1251,7 @@ static void mem_print(uint32_t *pstart, int *plast_prot,
}
}
-static void mem_info(void)
+static void mem_info(Monitor *mon)
{
CPUState *env;
int l1, l2, prot, last_prot;
@@ -1248,7 +1262,7 @@ static void mem_info(void)
return;
if (!(env->cr[0] & CR0_PG_MASK)) {
- term_printf("PG disabled\n");
+ monitor_printf(mon, "PG disabled\n");
return;
}
pgd = env->cr[3] & ~0xfff;
@@ -1261,7 +1275,7 @@ static void mem_info(void)
if (pde & PG_PRESENT_MASK) {
if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
- mem_print(&start, &last_prot, end, prot);
+ mem_print(mon, &start, &last_prot, end, prot);
} else {
for(l2 = 0; l2 < 1024; l2++) {
cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
@@ -1273,12 +1287,12 @@ static void mem_info(void)
} else {
prot = 0;
}
- mem_print(&start, &last_prot, end, prot);
+ mem_print(mon, &start, &last_prot, end, prot);
}
}
} else {
prot = 0;
- mem_print(&start, &last_prot, end, prot);
+ mem_print(mon, &start, &last_prot, end, prot);
}
}
}
@@ -1286,34 +1300,34 @@ static void mem_info(void)
#if defined(TARGET_SH4)
-static void print_tlb(int idx, tlb_t *tlb)
+static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
{
- term_printf(" tlb%i:\t"
- "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
- "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
- "dirty=%hhu writethrough=%hhu\n",
- idx,
- tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
- tlb->v, tlb->sh, tlb->c, tlb->pr,
- tlb->d, tlb->wt);
+ monitor_printf(mon, " tlb%i:\t"
+ "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
+ "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
+ "dirty=%hhu writethrough=%hhu\n",
+ idx,
+ tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
+ tlb->v, tlb->sh, tlb->c, tlb->pr,
+ tlb->d, tlb->wt);
}
-static void tlb_info(void)
+static void tlb_info(Monitor *mon)
{
CPUState *env = mon_get_cpu();
int i;
- term_printf ("ITLB:\n");
+ monitor_printf (mon, "ITLB:\n");
for (i = 0 ; i < ITLB_SIZE ; i++)
- print_tlb (i, &env->itlb[i]);
- term_printf ("UTLB:\n");
+ print_tlb (mon, i, &env->itlb[i]);
+ monitor_printf (mon, "UTLB:\n");
for (i = 0 ; i < UTLB_SIZE ; i++)
- print_tlb (i, &env->utlb[i]);
+ print_tlb (mon, i, &env->utlb[i]);
}
#endif
-static void do_info_kqemu(void)
+static void do_info_kqemu(Monitor *mon)
{
#ifdef USE_KQEMU
CPUState *env;
@@ -1321,38 +1335,38 @@ static void do_info_kqemu(void)
val = 0;
env = mon_get_cpu();
if (!env) {
- term_printf("No cpu initialized yet");
+ monitor_printf(mon, "No cpu initialized yet");
return;
}
val = env->kqemu_enabled;
- term_printf("kqemu support: ");
+ monitor_printf(mon, "kqemu support: ");
switch(val) {
default:
case 0:
- term_printf("disabled\n");
+ monitor_printf(mon, "disabled\n");
break;
case 1:
- term_printf("enabled for user code\n");
+ monitor_printf(mon, "enabled for user code\n");
break;
case 2:
- term_printf("enabled for user and kernel code\n");
+ monitor_printf(mon, "enabled for user and kernel code\n");
break;
}
#else
- term_printf("kqemu support: not compiled\n");
+ monitor_printf(mon, "kqemu support: not compiled\n");
#endif
}
-static void do_info_kvm(void)
+static void do_info_kvm(Monitor *mon)
{
#ifdef CONFIG_KVM
- term_printf("kvm support: ");
+ monitor_printf(mon, "kvm support: ");
if (kvm_enabled())
- term_printf("enabled\n");
+ monitor_printf(mon, "enabled\n");
else
- term_printf("disabled\n");
+ monitor_printf(mon, "disabled\n");
#else
- term_printf("kvm support: not compiled\n");
+ monitor_printf(mon, "kvm support: not compiled\n");
#endif
}
@@ -1366,23 +1380,25 @@ int64_t kqemu_ret_int_count;
int64_t kqemu_ret_excp_count;
int64_t kqemu_ret_intr_count;
-static void do_info_profile(void)
+static void do_info_profile(Monitor *mon)
{
int64_t total;
total = qemu_time;
if (total == 0)
total = 1;
- term_printf("async time %" PRId64 " (%0.3f)\n",
- dev_time, dev_time / (double)ticks_per_sec);
- term_printf("qemu time %" PRId64 " (%0.3f)\n",
- qemu_time, qemu_time / (double)ticks_per_sec);
- term_printf("kqemu time %" PRId64 " (%0.3f %0.1f%%) count=%" PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%" PRId64 "\n",
- kqemu_time, kqemu_time / (double)ticks_per_sec,
- kqemu_time / (double)total * 100.0,
- kqemu_exec_count,
- kqemu_ret_int_count,
- kqemu_ret_excp_count,
- kqemu_ret_intr_count);
+ monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
+ dev_time, dev_time / (double)ticks_per_sec);
+ monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
+ qemu_time, qemu_time / (double)ticks_per_sec);
+ monitor_printf(mon, "kqemu time %" PRId64 " (%0.3f %0.1f%%) count=%"
+ PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%"
+ PRId64 "\n",
+ kqemu_time, kqemu_time / (double)ticks_per_sec,
+ kqemu_time / (double)total * 100.0,
+ kqemu_exec_count,
+ kqemu_ret_int_count,
+ kqemu_ret_excp_count,
+ kqemu_ret_intr_count);
qemu_time = 0;
kqemu_time = 0;
kqemu_exec_count = 0;
@@ -1395,27 +1411,27 @@ static void do_info_profile(void)
#endif
}
#else
-static void do_info_profile(void)
+static void do_info_profile(Monitor *mon)
{
- term_printf("Internal profiler not compiled\n");
+ monitor_printf(mon, "Internal profiler not compiled\n");
}
#endif
/* Capture support */
static LIST_HEAD (capture_list_head, CaptureState) capture_head;
-static void do_info_capture (void)
+static void do_info_capture(Monitor *mon)
{
int i;
CaptureState *s;
for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
- term_printf ("[%d]: ", i);
+ monitor_printf(mon, "[%d]: ", i);
s->ops.info (s->opaque);
}
}
-static void do_stop_capture (int n)
+static void do_stop_capture(Monitor *mon, int n)
{
int i;
CaptureState *s;
@@ -1431,10 +1447,10 @@ static void do_stop_capture (int n)
}
#ifdef HAS_AUDIO
-static void do_wav_capture (const char *path,
- int has_freq, int freq,
- int has_bits, int bits,
- int has_channels, int nchannels)
+static void do_wav_capture(Monitor *mon, const char *path,
+ int has_freq, int freq,
+ int has_bits, int bits,
+ int has_channels, int nchannels)
{
CaptureState *s;
@@ -1445,7 +1461,7 @@ static void do_wav_capture (const char *path,
nchannels = has_channels ? nchannels : 2;
if (wav_start_capture (s, path, freq, bits, nchannels)) {
- term_printf ("Faied to add wave capture\n");
+ monitor_printf(mon, "Faied to add wave capture\n");
qemu_free (s);
}
LIST_INSERT_HEAD (&capture_head, s, entries);
@@ -1453,7 +1469,7 @@ static void do_wav_capture (const char *path,
#endif
#if defined(TARGET_I386)
-static void do_inject_nmi(int cpu_index)
+static void do_inject_nmi(Monitor *mon, int cpu_index)
{
CPUState *env;
@@ -1465,37 +1481,38 @@ static void do_inject_nmi(int cpu_index)
}
#endif
-static void do_info_status(void)
+static void do_info_status(Monitor *mon)
{
if (vm_running)
- term_printf("VM status: running\n");
+ monitor_printf(mon, "VM status: running\n");
else
- term_printf("VM status: paused\n");
+ monitor_printf(mon, "VM status: paused\n");
}
-static void do_balloon(int value)
+static void do_balloon(Monitor *mon, int value)
{
ram_addr_t target = value;
qemu_balloon(target << 20);
}
-static void do_info_balloon(void)
+static void do_info_balloon(Monitor *mon)
{
ram_addr_t actual;
actual = qemu_balloon_status();
if (kvm_enabled() && !kvm_has_sync_mmu())
- term_printf("Using KVM without synchronous MMU, ballooning disabled\n");
+ monitor_printf(mon, "Using KVM without synchronous MMU, "
+ "ballooning disabled\n");
else if (actual == 0)
- term_printf("Ballooning not activated in VM\n");
+ monitor_printf(mon, "Ballooning not activated in VM\n");
else
- term_printf("balloon: actual=%d\n", (int)(actual >> 20));
+ monitor_printf(mon, "balloon: actual=%d\n", (int)(actual >> 20));
}
/* Please update qemu-doc.texi when adding or changing commands */
-static const term_cmd_t term_cmds[] = {
- { "help|?", "s?", do_help,
+static const mon_cmd_t mon_cmds[] = {
+ { "help|?", "s?", help_cmd,
"[cmd]", "show the help" },
{ "commit", "s", do_commit,
"device|all", "commit changes to the disk images (if -snapshot is used) or backing files" },
@@ -1601,16 +1618,16 @@ static const term_cmd_t term_cmds[] = {
};
/* Please update qemu-doc.texi when adding or changing commands */
-static const term_cmd_t info_cmds[] = {
+static const mon_cmd_t info_cmds[] = {
{ "version", "", do_info_version,
"", "show the version of QEMU" },
{ "network", "", do_info_network,
"", "show the network state" },
{ "chardev", "", qemu_chr_info,
"", "show the character devices" },
- { "block", "", do_info_block,
+ { "block", "", bdrv_info,
"", "show the block devices" },
- { "blockstats", "", do_info_blockstats,
+ { "blockstats", "", bdrv_info_stats,
"", "show block device statistics" },
{ "registers", "", do_info_registers,
"", "show the cpu registers" },
@@ -2020,9 +2037,9 @@ static const MonitorDef monitor_defs[] = {
{ NULL },
};
-static void expr_error(const char *msg)
+static void expr_error(Monitor *mon, const char *msg)
{
- term_printf("%s\n", msg);
+ monitor_printf(mon, "%s\n", msg);
longjmp(expr_env, 1);
}
@@ -2068,9 +2085,9 @@ static void next(void)
}
}
-static int64_t expr_sum(void);
+static int64_t expr_sum(Monitor *mon);
-static int64_t expr_unary(void)
+static int64_t expr_unary(Monitor *mon)
{
int64_t n;
char *p;
@@ -2079,32 +2096,32 @@ static int64_t expr_unary(void)
switch(*pch) {
case '+':
next();
- n = expr_unary();
+ n = expr_unary(mon);
break;
case '-':
next();
- n = -expr_unary();
+ n = -expr_unary(mon);
break;
case '~':
next();
- n = ~expr_unary();
+ n = ~expr_unary(mon);
break;
case '(':
next();
- n = expr_sum();
+ n = expr_sum(mon);
if (*pch != ')') {
- expr_error("')' expected");
+ expr_error(mon, "')' expected");
}
next();
break;
case '\'':
pch++;
if (*pch == '\0')
- expr_error("character constant expected");
+ expr_error(mon, "character constant expected");
n = *pch;
pch++;
if (*pch != '\'')
- expr_error("missing terminating \' character");
+ expr_error(mon, "missing terminating \' character");
next();
break;
case '$':
@@ -2127,14 +2144,14 @@ static int64_t expr_unary(void)
*q = 0;
ret = get_monitor_def(&reg, buf);
if (ret == -1)
- expr_error("unknown register");
+ expr_error(mon, "unknown register");
else if (ret == -2)
- expr_error("no cpu defined");
+ expr_error(mon, "no cpu defined");
n = reg;
}
break;
case '\0':
- expr_error("unexpected end of expression");
+ expr_error(mon, "unexpected end of expression");
n = 0;
break;
default:
@@ -2144,7 +2161,7 @@ static int64_t expr_unary(void)
n = strtoul(pch, &p, 0);
#endif
if (pch == p) {
- expr_error("invalid char in expression");
+ expr_error(mon, "invalid char in expression");
}
pch = p;
while (qemu_isspace(*pch))
@@ -2155,18 +2172,18 @@ static int64_t expr_unary(void)
}
-static int64_t expr_prod(void)
+static int64_t expr_prod(Monitor *mon)
{
int64_t val, val2;
int op;
- val = expr_unary();
+ val = expr_unary(mon);
for(;;) {
op = *pch;
if (op != '*' && op != '/' && op != '%')
break;
next();
- val2 = expr_unary();
+ val2 = expr_unary(mon);
switch(op) {
default:
case '*':
@@ -2175,7 +2192,7 @@ static int64_t expr_prod(void)
case '/':
case '%':
if (val2 == 0)
- expr_error("division by zero");
+ expr_error(mon, "division by zero");
if (op == '/')
val /= val2;
else
@@ -2186,18 +2203,18 @@ static int64_t expr_prod(void)
return val;
}
-static int64_t expr_logic(void)
+static int64_t expr_logic(Monitor *mon)
{
int64_t val, val2;
int op;
- val = expr_prod();
+ val = expr_prod(mon);
for(;;) {
op = *pch;
if (op != '&' && op != '|' && op != '^')
break;
next();
- val2 = expr_prod();
+ val2 = expr_prod(mon);
switch(op) {
default:
case '&':
@@ -2214,18 +2231,18 @@ static int64_t expr_logic(void)
return val;
}
-static int64_t expr_sum(void)
+static int64_t expr_sum(Monitor *mon)
{
int64_t val, val2;
int op;
- val = expr_logic();
+ val = expr_logic(mon);
for(;;) {
op = *pch;
if (op != '+' && op != '-')
break;
next();
- val2 = expr_logic();
+ val2 = expr_logic(mon);
if (op == '+')
val += val2;
else
@@ -2234,7 +2251,7 @@ static int64_t expr_sum(void)
return val;
}
-static int get_expr(int64_t *pval, const char **pp)
+static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
{
pch = *pp;
if (setjmp(expr_env)) {
@@ -2243,7 +2260,7 @@ static int get_expr(int64_t *pval, const char **pp)
}
while (qemu_isspace(*pch))
pch++;
- *pval = expr_sum();
+ *pval = expr_sum(mon);
*pp = pch;
return 0;
}
@@ -2318,30 +2335,31 @@ static int default_fmt_size = 4;
#define MAX_ARGS 16
-static void monitor_handle_command(const char *cmdline)
+static void monitor_handle_command(Monitor *mon, const char *cmdline)
{
const char *p, *pstart, *typestr;
char *q;
int c, nb_args, len, i, has_arg;
- const term_cmd_t *cmd;
+ const mon_cmd_t *cmd;
char cmdname[256];
char buf[1024];
void *str_allocated[MAX_ARGS];
void *args[MAX_ARGS];
- void (*handler_0)(void);
- void (*handler_1)(void *arg0);
- void (*handler_2)(void *arg0, void *arg1);
- void (*handler_3)(void *arg0, void *arg1, void *arg2);
- void (*handler_4)(void *arg0, void *arg1, void *arg2, void *arg3);
- void (*handler_5)(void *arg0, void *arg1, void *arg2, void *arg3,
- void *arg4);
- void (*handler_6)(void *arg0, void *arg1, void *arg2, void *arg3,
- void *arg4, void *arg5);
- void (*handler_7)(void *arg0, void *arg1, void *arg2, void *arg3,
- void *arg4, void *arg5, void *arg6);
+ void (*handler_0)(Monitor *mon);
+ void (*handler_1)(Monitor *mon, void *arg0);
+ void (*handler_2)(Monitor *mon, void *arg0, void *arg1);
+ void (*handler_3)(Monitor *mon, void *arg0, void *arg1, void *arg2);
+ void (*handler_4)(Monitor *mon, void *arg0, void *arg1, void *arg2,
+ void *arg3);
+ void (*handler_5)(Monitor *mon, void *arg0, void *arg1, void *arg2,
+ void *arg3, void *arg4);
+ void (*handler_6)(Monitor *mon, void *arg0, void *arg1, void *arg2,
+ void *arg3, void *arg4, void *arg5);
+ void (*handler_7)(Monitor *mon, void *arg0, void *arg1, void *arg2,
+ void *arg3, void *arg4, void *arg5, void *arg6);
#ifdef DEBUG
- term_printf("command='%s'\n", cmdline);
+ monitor_printf(mon, "command='%s'\n", cmdline);
#endif
/* extract the command name */
@@ -2361,11 +2379,11 @@ static void monitor_handle_command(const char *cmdline)
cmdname[len] = '\0';
/* find the command */
- for(cmd = term_cmds; cmd->name != NULL; cmd++) {
+ for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
if (compare_cmd(cmdname, cmd->name))
goto found;
}
- term_printf("unknown command: '%s'\n", cmdname);
+ monitor_printf(mon, "unknown command: '%s'\n", cmdname);
return;
found:
@@ -2402,13 +2420,15 @@ static void monitor_handle_command(const char *cmdline)
if (ret < 0) {
switch(c) {
case 'F':
- term_printf("%s: filename expected\n", cmdname);
+ monitor_printf(mon, "%s: filename expected\n",
+ cmdname);
break;
case 'B':
- term_printf("%s: block device name expected\n", cmdname);
+ monitor_printf(mon, "%s: block device name expected\n",
+ cmdname);
break;
default:
- term_printf("%s: string expected\n", cmdname);
+ monitor_printf(mon, "%s: string expected\n", cmdname);
break;
}
goto fail;
@@ -2419,7 +2439,7 @@ static void monitor_handle_command(const char *cmdline)
add_str:
if (nb_args >= MAX_ARGS) {
error_args:
- term_printf("%s: too many arguments\n", cmdname);
+ monitor_printf(mon, "%s: too many arguments\n", cmdname);
goto fail;
}
args[nb_args++] = str;
@@ -2477,7 +2497,8 @@ static void monitor_handle_command(const char *cmdline)
}
next:
if (*p != '\0' && !qemu_isspace(*p)) {
- term_printf("invalid char in format: '%c'\n", *p);
+ monitor_printf(mon, "invalid char in format: '%c'\n",
+ *p);
goto fail;
}
if (format < 0)
@@ -2539,7 +2560,7 @@ static void monitor_handle_command(const char *cmdline)
goto add_num;
}
}
- if (get_expr(&val, &p))
+ if (get_expr(mon, &val, &p))
goto fail;
add_num:
if (c == 'i') {
@@ -2572,8 +2593,8 @@ static void monitor_handle_command(const char *cmdline)
if (*p == '-') {
p++;
if (*p != c) {
- term_printf("%s: unsupported option -%c\n",
- cmdname, *p);
+ monitor_printf(mon, "%s: unsupported option -%c\n",
+ cmdname, *p);
goto fail;
}
p++;
@@ -2586,7 +2607,7 @@ static void monitor_handle_command(const char *cmdline)
break;
default:
bad_type:
- term_printf("%s: unknown type '%c'\n", cmdname, c);
+ monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
goto fail;
}
}
@@ -2594,46 +2615,47 @@ static void monitor_handle_command(const char *cmdline)
while (qemu_isspace(*p))
p++;
if (*p != '\0') {
- term_printf("%s: extraneous characters at the end of line\n",
- cmdname);
+ monitor_printf(mon, "%s: extraneous characters at the end of line\n",
+ cmdname);
goto fail;
}
switch(nb_args) {
case 0:
handler_0 = cmd->handler;
- handler_0();
+ handler_0(mon);
break;
case 1:
handler_1 = cmd->handler;
- handler_1(args[0]);
+ handler_1(mon, args[0]);
break;
case 2:
handler_2 = cmd->handler;
- handler_2(args[0], args[1]);
+ handler_2(mon, args[0], args[1]);
break;
case 3:
handler_3 = cmd->handler;
- handler_3(args[0], args[1], args[2]);
+ handler_3(mon, args[0], args[1], args[2]);
break;
case 4:
handler_4 = cmd->handler;
- handler_4(args[0], args[1], args[2], args[3]);
+ handler_4(mon, args[0], args[1], args[2], args[3]);
break;
case 5:
handler_5 = cmd->handler;
- handler_5(args[0], args[1], args[2], args[3], args[4]);
+ handler_5(mon, args[0], args[1], args[2], args[3], args[4]);
break;
case 6:
handler_6 = cmd->handler;
- handler_6(args[0], args[1], args[2], args[3], args[4], args[5]);
+ handler_6(mon, args[0], args[1], args[2], args[3], args[4], args[5]);
break;
case 7:
handler_7 = cmd->handler;
- handler_7(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+ handler_7(mon, args[0], args[1], args[2], args[3], args[4], args[5],
+ args[6]);
break;
default:
- term_printf("unsupported number of arguments: %d\n", nb_args);
+ monitor_printf(mon, "unsupported number of arguments: %d\n", nb_args);
goto fail;
}
fail:
@@ -2660,7 +2682,7 @@ static void cmd_completion(const char *name, const char *list)
memcpy(cmd, pstart, len);
cmd[len] = '\0';
if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
- add_completion(cmd);
+ readline_add_completion(cmd);
}
if (*p == '\0')
break;
@@ -2691,7 +2713,8 @@ static void file_completion(const char *input)
pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
}
#ifdef DEBUG_COMPLETION
- term_printf("input='%s' path='%s' prefix='%s'\n", input, path, file_prefix);
+ monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
+ input, path, file_prefix);
#endif
ffs = opendir(path);
if (!ffs)
@@ -2712,7 +2735,7 @@ static void file_completion(const char *input)
stat(file, &sb);
if(S_ISDIR(sb.st_mode))
pstrcat(file, sizeof(file), "/");
- add_completion(file);
+ readline_add_completion(file);
}
}
closedir(ffs);
@@ -2725,7 +2748,7 @@ static void block_completion_it(void *opaque, BlockDriverState *bs)
if (input[0] == '\0' ||
!strncmp(name, (char *)input, strlen(input))) {
- add_completion(name);
+ readline_add_completion(name);
}
}
@@ -2761,13 +2784,13 @@ void readline_find_completion(const char *cmdline)
char *args[MAX_ARGS];
int nb_args, i, len;
const char *ptype, *str;
- const term_cmd_t *cmd;
+ const mon_cmd_t *cmd;
const KeyDef *key;
parse_cmdline(cmdline, &nb_args, args);
#ifdef DEBUG_COMPLETION
for(i = 0; i < nb_args; i++) {
- term_printf("arg%d = '%s'\n", i, (char *)args[i]);
+ monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
}
#endif
@@ -2785,13 +2808,13 @@ void readline_find_completion(const char *cmdline)
cmdname = "";
else
cmdname = args[0];
- completion_index = strlen(cmdname);
- for(cmd = term_cmds; cmd->name != NULL; cmd++) {
+ readline_set_completion_index(strlen(cmdname));
+ for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
cmd_completion(cmdname, cmd->name);
}
} else {
/* find the command */
- for(cmd = term_cmds; cmd->name != NULL; cmd++) {
+ for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
if (compare_cmd(args[0], cmd->name))
goto found;
}
@@ -2809,23 +2832,23 @@ void readline_find_completion(const char *cmdline)
switch(*ptype) {
case 'F':
/* file completion */
- completion_index = strlen(str);
+ readline_set_completion_index(strlen(str));
file_completion(str);
break;
case 'B':
/* block device name completion */
- completion_index = strlen(str);
+ readline_set_completion_index(strlen(str));
bdrv_iterate(block_completion_it, (void *)str);
break;
case 's':
/* XXX: more generic ? */
if (!strcmp(cmd->name, "info")) {
- completion_index = strlen(str);
+ readline_set_completion_index(strlen(str));
for(cmd = info_cmds; cmd->name != NULL; cmd++) {
cmd_completion(str, cmd->name);
}
} else if (!strcmp(cmd->name, "sendkey")) {
- completion_index = strlen(str);
+ readline_set_completion_index(strlen(str));
for(key = key_defs; key->name != NULL; key++) {
cmd_completion(str, key->name);
}
@@ -2847,27 +2870,28 @@ static int term_can_read(void *opaque)
static void term_read(void *opaque, const uint8_t *buf, int size)
{
int i;
- for(i = 0; i < size; i++)
+
+ for (i = 0; i < size; i++)
readline_handle_byte(buf[i]);
}
static int monitor_suspended;
-static void monitor_handle_command1(void *opaque, const char *cmdline)
+static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
{
- monitor_handle_command(cmdline);
+ monitor_handle_command(mon, cmdline);
if (!monitor_suspended)
readline_show_prompt();
else
monitor_suspended = 2;
}
-void monitor_suspend(void)
+void monitor_suspend(Monitor *mon)
{
monitor_suspended = 1;
}
-void monitor_resume(void)
+void monitor_resume(Monitor *mon)
{
if (monitor_suspended == 2)
monitor_start_input();
@@ -2876,24 +2900,26 @@ void monitor_resume(void)
static void monitor_start_input(void)
{
- readline_start("(qemu) ", 0, monitor_handle_command1, NULL);
+ readline_start("(qemu) ", 0, monitor_command_cb, NULL);
readline_show_prompt();
}
static void term_event(void *opaque, int event)
{
+ Monitor *mon = opaque;
+
if (event != CHR_EVENT_RESET)
return;
if (!hide_banner)
- term_printf("QEMU %s monitor - type 'help' for more information\n",
- QEMU_VERSION);
+ monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
+ "information\n", QEMU_VERSION);
monitor_start_input();
}
static int is_first_init = 1;
-void monitor_init(CharDriverState *hd, int show_banner)
+void monitor_init(CharDriverState *chr, int show_banner)
{
int i;
@@ -2908,25 +2934,25 @@ void monitor_init(CharDriverState *hd, int show_banner)
}
for (i = 0; i < MAX_MON; i++) {
if (monitor_hd[i] == NULL) {
- monitor_hd[i] = hd;
+ monitor_hd[i] = chr;
break;
}
}
hide_banner = !show_banner;
- qemu_chr_add_handlers(hd, term_can_read, term_read, term_event, NULL);
+ qemu_chr_add_handlers(chr, term_can_read, term_read, term_event, cur_mon);
- readline_start("", 0, monitor_handle_command1, NULL);
+ readline_start("", 0, monitor_command_cb, NULL);
}
-static void bdrv_password_cb(void *opaque, const char *password)
+static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
{
BlockDriverState *bs = opaque;
int ret = 0;
if (bdrv_set_key(bs, password) != 0) {
- term_printf("invalid password\n");
+ monitor_printf(mon, "invalid password\n");
ret = -EPERM;
}
if (password_completion_cb)
@@ -2935,7 +2961,7 @@ static void bdrv_password_cb(void *opaque, const char *password)
monitor_start_input();
}
-void monitor_read_bdrv_key_start(BlockDriverState *bs,
+void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
BlockDriverCompletionFunc *completion_cb,
void *opaque)
{
@@ -2945,11 +2971,11 @@ void monitor_read_bdrv_key_start(BlockDriverState *bs,
return;
}
- term_printf("%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
- bdrv_get_encrypted_filename(bs));
+ monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
+ bdrv_get_encrypted_filename(bs));
password_completion_cb = completion_cb;
password_opaque = opaque;
- monitor_read_password(bdrv_password_cb, bs);
+ monitor_read_password(mon, bdrv_password_cb, bs);
}
diff --git a/monitor.h b/monitor.h
new file mode 100644
index 0000000..d06e2d8
--- /dev/null
+++ b/monitor.h
@@ -0,0 +1,25 @@
+#ifndef MONITOR_H
+#define MONITOR_H
+
+#include "qemu-common.h"
+#include "qemu-char.h"
+#include "block.h"
+
+extern Monitor *cur_mon;
+
+void monitor_init(CharDriverState *chr, int show_banner);
+
+void monitor_suspend(Monitor *mon);
+void monitor_resume(Monitor *mon);
+
+void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
+ BlockDriverCompletionFunc *completion_cb,
+ void *opaque);
+
+void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap);
+void monitor_printf(Monitor *mon, const char *fmt, ...)
+ __attribute__ ((__format__ (__printf__, 2, 3)));
+void monitor_print_filename(Monitor *mon, const char *filename);
+void monitor_flush(Monitor *mon);
+
+#endif /* !MONITOR_H */
diff --git a/net.c b/net.c
index 522df03..ad75e3d 100644
--- a/net.c
+++ b/net.c
@@ -23,7 +23,7 @@
*/
#include "qemu-common.h"
#include "net.h"
-#include "console.h"
+#include "monitor.h"
#include "sysemu.h"
#include "qemu-timer.h"
#include "qemu-char.h"
@@ -665,7 +665,7 @@ void net_slirp_smb(const char *exported_dir)
}
#endif /* !defined(_WIN32) */
-void do_info_slirp(void)
+void do_info_slirp(Monitor *mon)
{
slirp_stats();
}
@@ -1804,28 +1804,28 @@ static int net_host_check_device(const char *device)
return 0;
}
-void net_host_device_add(const char *device, const char *opts)
+void net_host_device_add(Monitor *mon, const char *device, const char *opts)
{
if (!net_host_check_device(device)) {
- term_printf("invalid host network device %s\n", device);
+ monitor_printf(mon, "invalid host network device %s\n", device);
return;
}
net_client_init(device, opts);
}
-void net_host_device_remove(int vlan_id, const char *device)
+void net_host_device_remove(Monitor *mon, int vlan_id, const char *device)
{
VLANState *vlan;
VLANClientState *vc;
if (!net_host_check_device(device)) {
- term_printf("invalid host network device %s\n", device);
+ monitor_printf(mon, "invalid host network device %s\n", device);
return;
}
vlan = qemu_find_vlan(vlan_id);
if (!vlan) {
- term_printf("can't find vlan %d\n", vlan_id);
+ monitor_printf(mon, "can't find vlan %d\n", vlan_id);
return;
}
@@ -1834,7 +1834,7 @@ void net_host_device_remove(int vlan_id, const char *device)
break;
if (!vc) {
- term_printf("can't find device %s\n", device);
+ monitor_printf(mon, "can't find device %s\n", device);
return;
}
qemu_del_vlan_client(vc);
@@ -1860,19 +1860,19 @@ int net_client_parse(const char *str)
return net_client_init(device, p);
}
-void do_info_network(void)
+void do_info_network(Monitor *mon)
{
VLANState *vlan;
VLANClientState *vc;
for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
- term_printf("VLAN %d devices:\n", vlan->id);
+ monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
for(vc = vlan->first_client; vc != NULL; vc = vc->next)
- term_printf(" %s: %s\n", vc->name, vc->info_str);
+ monitor_printf(mon, " %s: %s\n", vc->name, vc->info_str);
}
}
-int do_set_link(const char *name, const char *up_or_down)
+int do_set_link(Monitor *mon, const char *name, const char *up_or_down)
{
VLANState *vlan;
VLANClientState *vc = NULL;
@@ -1884,7 +1884,7 @@ int do_set_link(const char *name, const char *up_or_down)
done:
if (!vc) {
- term_printf("could not find network device '%s'", name);
+ monitor_printf(mon, "could not find network device '%s'", name);
return 0;
}
@@ -1893,8 +1893,8 @@ done:
else if (strcmp(up_or_down, "down") == 0)
vc->link_down = 1;
else
- term_printf("invalid link status '%s'; only 'up' or 'down' valid\n",
- up_or_down);
+ monitor_printf(mon, "invalid link status '%s'; only 'up' or 'down' "
+ "valid\n", up_or_down);
if (vc->link_status_changed)
vc->link_status_changed(vc);
diff --git a/net.h b/net.h
index 03c7f18..1a51be7 100644
--- a/net.h
+++ b/net.h
@@ -53,8 +53,8 @@ void qemu_check_nic_model_list(NICInfo *nd, const char * const *models,
const char *default_model);
void qemu_handler_true(void *opaque);
-void do_info_network(void);
-int do_set_link(const char *name, const char *up_or_down);
+void do_info_network(Monitor *mon);
+int do_set_link(Monitor *mon, const char *name, const char *up_or_down);
/* NIC info */
@@ -102,8 +102,8 @@ void net_slirp_redir(const char *redir_str);
void net_cleanup(void);
int slirp_is_inited(void);
void net_client_check(void);
-void net_host_device_add(const char *device, const char *opts);
-void net_host_device_remove(int vlan_id, const char *device);
+void net_host_device_add(Monitor *mon, const char *device, const char *opts);
+void net_host_device_remove(Monitor *mon, int vlan_id, const char *device);
#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
diff --git a/qemu-char.c b/qemu-char.c
index 1fd3aef..d4ff367 100644
--- a/qemu-char.c
+++ b/qemu-char.c
@@ -23,6 +23,7 @@
*/
#include "qemu-common.h"
#include "net.h"
+#include "monitor.h"
#include "console.h"
#include "sysemu.h"
#include "qemu-timer.h"
@@ -2199,11 +2200,11 @@ void qemu_chr_close(CharDriverState *chr)
qemu_free(chr);
}
-void qemu_chr_info(void)
+void qemu_chr_info(Monitor *mon)
{
CharDriverState *chr;
TAILQ_FOREACH(chr, &chardevs, next) {
- term_printf("%s: filename=%s\n", chr->label, chr->filename);
+ monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename);
}
}
diff --git a/qemu-char.h b/qemu-char.h
index 9ff6b99..e5ad45c 100644
--- a/qemu-char.h
+++ b/qemu-char.h
@@ -1,7 +1,9 @@
#ifndef QEMU_CHAR_H
#define QEMU_CHAR_H
+#include "qemu-common.h"
#include "sys-queue.h"
+
/* character device */
#define CHR_EVENT_BREAK 0 /* serial break char */
@@ -78,7 +80,7 @@ void qemu_chr_initial_reset(void);
int qemu_chr_can_read(CharDriverState *s);
void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len);
void qemu_chr_accept_input(CharDriverState *s);
-void qemu_chr_info(void);
+void qemu_chr_info(Monitor *mon);
extern int term_escape_char;
diff --git a/qemu-common.h b/qemu-common.h
index db33493..f8ac7e6 100644
--- a/qemu-common.h
+++ b/qemu-common.h
@@ -205,6 +205,9 @@ void qemu_iovec_reset(QEMUIOVector *qiov);
void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf);
void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count);
+struct Monitor;
+typedef struct Monitor Monitor;
+
#endif /* dyngen-exec.h hack */
#endif
diff --git a/qemu-tool.c b/qemu-tool.c
index 4dda5af..c08f061 100644
--- a/qemu-tool.c
+++ b/qemu-tool.c
@@ -12,7 +12,7 @@
*/
#include "qemu-common.h"
-#include "console.h"
+#include "monitor.h"
#include "sysemu.h"
#include "qemu-timer.h"
@@ -30,11 +30,13 @@ void qemu_service_io(void)
{
}
-void term_printf(const char *fmt, ...)
+Monitor *cur_mon;
+
+void monitor_printf(Monitor *mon, const char *fmt, ...)
{
}
-void term_print_filename(const char *filename)
+void monitor_print_filename(Monitor *mon, const char *filename)
{
}
diff --git a/readline.c b/readline.c
index 5a089be..ffa5424 100644
--- a/readline.c
+++ b/readline.c
@@ -21,8 +21,8 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
-#include "qemu-common.h"
-#include "console.h"
+#include "readline.h"
+#include "monitor.h"
#define TERM_CMD_BUF_SIZE 4095
#define TERM_MAX_CMDS 64
@@ -49,7 +49,7 @@ static char *term_history[TERM_MAX_CMDS];
static int term_hist_entry = -1;
static int nb_completions;
-int completion_index;
+static int completion_index;
static char *completions[NB_COMPLETIONS_MAX];
static ReadLineFunc *term_readline_func;
@@ -59,8 +59,10 @@ static void *term_readline_opaque;
void readline_show_prompt(void)
{
- term_printf("%s", term_prompt);
- term_flush();
+ Monitor *mon = cur_mon;
+
+ monitor_printf(mon, "%s", term_prompt);
+ monitor_flush(mon);
term_last_cmd_buf_index = 0;
term_last_cmd_buf_size = 0;
term_esc_state = IS_NORM;
@@ -69,22 +71,23 @@ void readline_show_prompt(void)
/* update the displayed command line */
static void term_update(void)
{
+ Monitor *mon = cur_mon;
int i, delta, len;
if (term_cmd_buf_size != term_last_cmd_buf_size ||
memcmp(term_cmd_buf, term_last_cmd_buf, term_cmd_buf_size) != 0) {
for(i = 0; i < term_last_cmd_buf_index; i++) {
- term_printf("\033[D");
+ monitor_printf(mon, "\033[D");
}
term_cmd_buf[term_cmd_buf_size] = '\0';
if (term_is_password) {
len = strlen(term_cmd_buf);
for(i = 0; i < len; i++)
- term_printf("*");
+ monitor_printf(mon, "*");
} else {
- term_printf("%s", term_cmd_buf);
+ monitor_printf(mon, "%s", term_cmd_buf);
}
- term_printf("\033[K");
+ monitor_printf(mon, "\033[K");
memcpy(term_last_cmd_buf, term_cmd_buf, term_cmd_buf_size);
term_last_cmd_buf_size = term_cmd_buf_size;
term_last_cmd_buf_index = term_cmd_buf_size;
@@ -93,17 +96,17 @@ static void term_update(void)
delta = term_cmd_buf_index - term_last_cmd_buf_index;
if (delta > 0) {
for(i = 0;i < delta; i++) {
- term_printf("\033[C");
+ monitor_printf(mon, "\033[C");
}
} else {
delta = -delta;
for(i = 0;i < delta; i++) {
- term_printf("\033[D");
+ monitor_printf(mon, "\033[D");
}
}
term_last_cmd_buf_index = term_cmd_buf_index;
}
- term_flush();
+ monitor_flush(mon);
}
static void term_insert_char(int ch)
@@ -285,15 +288,21 @@ static void term_hist_add(const char *cmdline)
/* completion support */
-void add_completion(const char *str)
+void readline_add_completion(const char *str)
{
if (nb_completions < NB_COMPLETIONS_MAX) {
completions[nb_completions++] = qemu_strdup(str);
}
}
+void readline_set_completion_index(int index)
+{
+ completion_index = index;
+}
+
static void term_completion(void)
{
+ Monitor *mon = cur_mon;
int len, i, j, max_width, nb_cols, max_prefix;
char *cmdline;
@@ -317,7 +326,7 @@ static void term_completion(void)
if (len > 0 && completions[0][len - 1] != '/')
term_insert_char(' ');
} else {
- term_printf("\n");
+ monitor_printf(mon, "\n");
max_width = 0;
max_prefix = 0;
for(i = 0; i < nb_completions; i++) {
@@ -347,9 +356,9 @@ static void term_completion(void)
nb_cols = 80 / max_width;
j = 0;
for(i = 0; i < nb_completions; i++) {
- term_printf("%-*s", max_width, completions[i]);
+ monitor_printf(mon, "%-*s", max_width, completions[i]);
if (++j == nb_cols || i == (nb_completions - 1)) {
- term_printf("\n");
+ monitor_printf(mon, "\n");
j = 0;
}
}
@@ -360,6 +369,8 @@ static void term_completion(void)
/* return true if command handled */
void readline_handle_byte(int ch)
{
+ Monitor *mon = cur_mon;
+
switch(term_esc_state) {
case IS_NORM:
switch(ch) {
@@ -380,13 +391,13 @@ void readline_handle_byte(int ch)
term_cmd_buf[term_cmd_buf_size] = '\0';
if (!term_is_password)
term_hist_add(term_cmd_buf);
- term_printf("\n");
+ monitor_printf(mon, "\n");
term_cmd_buf_index = 0;
term_cmd_buf_size = 0;
term_last_cmd_buf_index = 0;
term_last_cmd_buf_size = 0;
/* NOTE: readline_start can be called here */
- term_readline_func(term_readline_opaque, term_cmd_buf);
+ term_readline_func(mon, term_cmd_buf, term_readline_opaque);
break;
case 23:
/* ^W */
diff --git a/readline.h b/readline.h
new file mode 100644
index 0000000..c5c10d6
--- /dev/null
+++ b/readline.h
@@ -0,0 +1,20 @@
+#ifndef READLINE_H
+#define READLINE_H
+
+#include "qemu-common.h"
+
+typedef void ReadLineFunc(Monitor *mon, const char *str, void *opaque);
+
+void readline_add_completion(const char *str);
+void readline_set_completion_index(int index);
+void readline_find_completion(const char *cmdline);
+
+const char *readline_get_history(unsigned int index);
+
+void readline_handle_byte(int ch);
+
+void readline_start(const char *prompt, int is_password,
+ ReadLineFunc *readline_func, void *opaque);
+void readline_show_prompt(void);
+
+#endif /* !READLINE_H */
diff --git a/savevm.c b/savevm.c
index 3eb2000..bea6885 100644
--- a/savevm.c
+++ b/savevm.c
@@ -24,7 +24,7 @@
#include "qemu-common.h"
#include "hw/hw.h"
#include "net.h"
-#include "console.h"
+#include "monitor.h"
#include "sysemu.h"
#include "qemu-timer.h"
#include "qemu-char.h"
@@ -993,7 +993,7 @@ static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
return ret;
}
-void do_savevm(const char *name)
+void do_savevm(Monitor *mon, const char *name)
{
BlockDriverState *bs, *bs1;
QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
@@ -1010,7 +1010,7 @@ void do_savevm(const char *name)
bs = get_bs_snapshots();
if (!bs) {
- term_printf("No block device can accept snapshots\n");
+ monitor_printf(mon, "No block device can accept snapshots\n");
return;
}
@@ -1049,22 +1049,22 @@ void do_savevm(const char *name)
sn->vm_clock_nsec = qemu_get_clock(vm_clock);
if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
- term_printf("Device %s does not support VM state snapshots\n",
- bdrv_get_device_name(bs));
+ monitor_printf(mon, "Device %s does not support VM state snapshots\n",
+ bdrv_get_device_name(bs));
goto the_end;
}
/* save the VM state */
f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
if (!f) {
- term_printf("Could not open VM state file\n");
+ monitor_printf(mon, "Could not open VM state file\n");
goto the_end;
}
ret = qemu_savevm_state(f);
vm_state_size = qemu_ftell(f);
qemu_fclose(f);
if (ret < 0) {
- term_printf("Error %d while writing VM\n", ret);
+ monitor_printf(mon, "Error %d while writing VM\n", ret);
goto the_end;
}
@@ -1076,16 +1076,17 @@ void do_savevm(const char *name)
if (must_delete) {
ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
if (ret < 0) {
- term_printf("Error while deleting snapshot on '%s'\n",
- bdrv_get_device_name(bs1));
+ monitor_printf(mon,
+ "Error while deleting snapshot on '%s'\n",
+ bdrv_get_device_name(bs1));
}
}
/* Write VM state size only to the image that contains the state */
sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
ret = bdrv_snapshot_create(bs1, sn);
if (ret < 0) {
- term_printf("Error while creating snapshot on '%s'\n",
- bdrv_get_device_name(bs1));
+ monitor_printf(mon, "Error while creating snapshot on '%s'\n",
+ bdrv_get_device_name(bs1));
}
}
}
@@ -1095,7 +1096,7 @@ void do_savevm(const char *name)
vm_start();
}
-void do_loadvm(const char *name)
+void do_loadvm(Monitor *mon, const char *name)
{
BlockDriverState *bs, *bs1;
BlockDriverInfo bdi1, *bdi = &bdi1;
@@ -1106,7 +1107,7 @@ void do_loadvm(const char *name)
bs = get_bs_snapshots();
if (!bs) {
- term_printf("No block device supports snapshots\n");
+ monitor_printf(mon, "No block device supports snapshots\n");
return;
}
@@ -1122,19 +1123,21 @@ void do_loadvm(const char *name)
ret = bdrv_snapshot_goto(bs1, name);
if (ret < 0) {
if (bs != bs1)
- term_printf("Warning: ");
+ monitor_printf(mon, "Warning: ");
switch(ret) {
case -ENOTSUP:
- term_printf("Snapshots not supported on device '%s'\n",
- bdrv_get_device_name(bs1));
+ monitor_printf(mon,
+ "Snapshots not supported on device '%s'\n",
+ bdrv_get_device_name(bs1));
break;
case -ENOENT:
- term_printf("Could not find snapshot '%s' on device '%s'\n",
- name, bdrv_get_device_name(bs1));
+ monitor_printf(mon, "Could not find snapshot '%s' on "
+ "device '%s'\n",
+ name, bdrv_get_device_name(bs1));
break;
default:
- term_printf("Error %d while activating snapshot on '%s'\n",
- ret, bdrv_get_device_name(bs1));
+ monitor_printf(mon, "Error %d while activating snapshot on"
+ " '%s'\n", ret, bdrv_get_device_name(bs1));
break;
}
/* fatal on snapshot block device */
@@ -1145,8 +1148,8 @@ void do_loadvm(const char *name)
}
if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
- term_printf("Device %s does not support VM state snapshots\n",
- bdrv_get_device_name(bs));
+ monitor_printf(mon, "Device %s does not support VM state snapshots\n",
+ bdrv_get_device_name(bs));
return;
}
@@ -1158,27 +1161,27 @@ void do_loadvm(const char *name)
/* restore the VM state */
f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
if (!f) {
- term_printf("Could not open VM state file\n");
+ monitor_printf(mon, "Could not open VM state file\n");
goto the_end;
}
ret = qemu_loadvm_state(f);
qemu_fclose(f);
if (ret < 0) {
- term_printf("Error %d while loading VM state\n", ret);
+ monitor_printf(mon, "Error %d while loading VM state\n", ret);
}
the_end:
if (saved_vm_running)
vm_start();
}
-void do_delvm(const char *name)
+void do_delvm(Monitor *mon, const char *name)
{
BlockDriverState *bs, *bs1;
int i, ret;
bs = get_bs_snapshots();
if (!bs) {
- term_printf("No block device supports snapshots\n");
+ monitor_printf(mon, "No block device supports snapshots\n");
return;
}
@@ -1188,17 +1191,18 @@ void do_delvm(const char *name)
ret = bdrv_snapshot_delete(bs1, name);
if (ret < 0) {
if (ret == -ENOTSUP)
- term_printf("Snapshots not supported on device '%s'\n",
- bdrv_get_device_name(bs1));
+ monitor_printf(mon,
+ "Snapshots not supported on device '%s'\n",
+ bdrv_get_device_name(bs1));
else
- term_printf("Error %d while deleting snapshot on '%s'\n",
- ret, bdrv_get_device_name(bs1));
+ monitor_printf(mon, "Error %d while deleting snapshot on "
+ "'%s'\n", ret, bdrv_get_device_name(bs1));
}
}
}
}
-void do_info_snapshots(void)
+void do_info_snapshots(Monitor *mon)
{
BlockDriverState *bs, *bs1;
QEMUSnapshotInfo *sn_tab, *sn;
@@ -1207,29 +1211,30 @@ void do_info_snapshots(void)
bs = get_bs_snapshots();
if (!bs) {
- term_printf("No available block device supports snapshots\n");
+ monitor_printf(mon, "No available block device supports snapshots\n");
return;
}
- term_printf("Snapshot devices:");
+ monitor_printf(mon, "Snapshot devices:");
for(i = 0; i <= nb_drives; i++) {
bs1 = drives_table[i].bdrv;
if (bdrv_has_snapshot(bs1)) {
if (bs == bs1)
- term_printf(" %s", bdrv_get_device_name(bs1));
+ monitor_printf(mon, " %s", bdrv_get_device_name(bs1));
}
}
- term_printf("\n");
+ monitor_printf(mon, "\n");
nb_sns = bdrv_snapshot_list(bs, &sn_tab);
if (nb_sns < 0) {
- term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
+ monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
return;
}
- term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
- term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
+ monitor_printf(mon, "Snapshot list (from %s):\n",
+ bdrv_get_device_name(bs));
+ monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
for(i = 0; i < nb_sns; i++) {
sn = &sn_tab[i];
- term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
+ monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
}
qemu_free(sn_tab);
}
diff --git a/slirp/misc.c b/slirp/misc.c
index f558b3c..b4c73d1 100644
--- a/slirp/misc.c
+++ b/slirp/misc.c
@@ -557,14 +557,14 @@ relay(s)
#endif
#ifdef CONFIG_QEMU
-extern void term_vprintf(const char *fmt, va_list ap);
+#include "monitor.h"
void lprint(const char *format, ...)
{
va_list args;
va_start(args, format);
- term_vprintf(format, args);
+ monitor_vprintf(cur_mon, format, args);
va_end(args);
}
#else
diff --git a/sysemu.h b/sysemu.h
index 57217c1..8775412 100644
--- a/sysemu.h
+++ b/sysemu.h
@@ -2,6 +2,8 @@
#define SYSEMU_H
/* Misc. things related to the system emulator. */
+#include "qemu-common.h"
+
/* vl.c */
extern const char *bios_name;
extern const char *bios_dir;
@@ -39,10 +41,10 @@ void qemu_system_powerdown(void);
#endif
void qemu_system_reset(void);
-void do_savevm(const char *name);
-void do_loadvm(const char *name);
-void do_delvm(const char *name);
-void do_info_snapshots(void);
+void do_savevm(Monitor *mon, const char *name);
+void do_loadvm(Monitor *mon, const char *name);
+void do_delvm(Monitor *mon, const char *name);
+void do_info_snapshots(Monitor *mon);
void qemu_announce_self(void);
@@ -75,7 +77,7 @@ int tap_win32_init(VLANState *vlan, const char *model,
const char *name, const char *ifname);
/* SLIRP */
-void do_info_slirp(void);
+void do_info_slirp(Monitor *mon);
extern int bios_size;
extern int cirrus_vga_enabled;
@@ -179,9 +181,10 @@ void destroy_nic(dev_match_fn *match_fn, void *arg);
void destroy_bdrvs(dev_match_fn *match_fn, void *arg);
/* pci-hotplug */
-void pci_device_hot_add(const char *pci_addr, const char *type, const char *opts);
-void drive_hot_add(const char *pci_addr, const char *opts);
-void pci_device_hot_remove(const char *pci_addr);
+void pci_device_hot_add(Monitor *mon, const char *pci_addr, const char *type,
+ const char *opts);
+void drive_hot_add(Monitor *mon, const char *pci_addr, const char *opts);
+void pci_device_hot_remove(Monitor *mon, const char *pci_addr);
void pci_device_hot_remove_success(int pcibus, int slot);
/* serial ports */
@@ -237,9 +240,9 @@ struct soundhw {
extern struct soundhw soundhw[];
#endif
-void do_usb_add(const char *devname);
-void do_usb_del(const char *devname);
-void usb_info(void);
+void do_usb_add(Monitor *mon, const char *devname);
+void do_usb_del(Monitor *mon, const char *devname);
+void usb_info(Monitor *mon);
const char *get_opt_name(char *buf, int buf_size, const char *p);
const char *get_opt_value(char *buf, int buf_size, const char *p);
diff --git a/usb-bsd.c b/usb-bsd.c
index fa4093c..22610ab 100644
--- a/usb-bsd.c
+++ b/usb-bsd.c
@@ -554,6 +554,7 @@ static void usb_info_device(int bus_num, int addr, int class_id,
int speed)
{
const char *class_str, *speed_str;
+ Monitor *mon = cur_mon;
switch(speed) {
case USB_SPEED_LOW:
@@ -570,20 +571,21 @@ static void usb_info_device(int bus_num, int addr, int class_id,
break;
}
- term_printf(" Device %d.%d, speed %s Mb/s\n",
- bus_num, addr, speed_str);
+ monitor_printf(mon, " Device %d.%d, speed %s Mb/s\n",
+ bus_num, addr, speed_str);
class_str = usb_class_str(class_id);
if (class_str)
- term_printf(" %s:", class_str);
+ monitor_printf(mon, " %s:", class_str);
else
- term_printf(" Class %02x:", class_id);
- term_printf(" USB device %04x:%04x", vendor_id, product_id);
+ monitor_printf(mon, " Class %02x:", class_id);
+ monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
if (product_name[0] != '\0')
- term_printf(", %s", product_name);
- term_printf("\n");
+ monitor_printf(mon, ", %s", product_name);
+ monitor_printf(mon, "\n");
}
-static int usb_host_info_device(void *opaque, int bus_num, int addr,
+static int usb_host_info_device(void *opaque,
+ int bus_num, int addr,
int class_id,
int vendor_id, int product_id,
const char *product_name,
@@ -594,7 +596,7 @@ static int usb_host_info_device(void *opaque, int bus_num, int addr,
return 0;
}
-void usb_host_info(void)
+void usb_host_info(Monitor *mon)
{
usb_host_scan(NULL, usb_host_info_device);
}
diff --git a/usb-linux.c b/usb-linux.c
index f19f0c4..70d7a1c 100644
--- a/usb-linux.c
+++ b/usb-linux.c
@@ -32,7 +32,7 @@
#include "qemu-common.h"
#include "qemu-timer.h"
-#include "console.h"
+#include "monitor.h"
#include <dirent.h>
#include <sys/ioctl.h>
@@ -985,6 +985,7 @@ static int usb_host_auto_del(const char *spec);
USBDevice *usb_host_device_open(const char *devname)
{
+ Monitor *mon = cur_mon;
int bus_num, addr;
char product_name[PRODUCT_NAME_SZ];
@@ -998,7 +999,8 @@ USBDevice *usb_host_device_open(const char *devname)
return NULL;
if (hostdev_find(bus_num, addr)) {
- term_printf("husb: host usb device %d.%d is already open\n", bus_num, addr);
+ monitor_printf(mon, "husb: host usb device %d.%d is already open\n",
+ bus_num, addr);
return NULL;
}
@@ -1149,6 +1151,7 @@ static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
*/
static int usb_host_read_file(char *line, size_t line_size, const char *device_file, const char *device_name)
{
+ Monitor *mon = cur_mon;
FILE *f;
int ret = 0;
char filename[PATH_MAX];
@@ -1161,7 +1164,7 @@ static int usb_host_read_file(char *line, size_t line_size, const char *device_f
fclose(f);
ret = 1;
} else {
- term_printf("husb: could not open %s\n", filename);
+ monitor_printf(mon, "husb: could not open %s\n", filename);
}
return ret;
@@ -1254,6 +1257,7 @@ static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
*/
static int usb_host_scan(void *opaque, USBScanFunc *func)
{
+ Monitor *mon = cur_mon;
FILE *f = 0;
DIR *dir = 0;
int ret = 0;
@@ -1292,14 +1296,15 @@ static int usb_host_scan(void *opaque, USBScanFunc *func)
}
found_devices:
if (!usb_fs_type) {
- term_printf("husb: unable to access USB devices\n");
+ monitor_printf(mon, "husb: unable to access USB devices\n");
return -ENOENT;
}
/* the module setting (used later for opening devices) */
usb_host_device_path = qemu_mallocz(strlen(devpath)+1);
strcpy(usb_host_device_path, devpath);
- term_printf("husb: using %s file-system with %s\n", fs_type[usb_fs_type], usb_host_device_path);
+ monitor_printf(mon, "husb: using %s file-system with %s\n",
+ fs_type[usb_fs_type], usb_host_device_path);
}
switch (usb_fs_type) {
@@ -1606,6 +1611,7 @@ static void usb_info_device(int bus_num, int addr, int class_id,
const char *product_name,
int speed)
{
+ Monitor *mon = cur_mon;
const char *class_str, *speed_str;
switch(speed) {
@@ -1623,17 +1629,17 @@ static void usb_info_device(int bus_num, int addr, int class_id,
break;
}
- term_printf(" Device %d.%d, speed %s Mb/s\n",
+ monitor_printf(mon, " Device %d.%d, speed %s Mb/s\n",
bus_num, addr, speed_str);
class_str = usb_class_str(class_id);
if (class_str)
- term_printf(" %s:", class_str);
+ monitor_printf(mon, " %s:", class_str);
else
- term_printf(" Class %02x:", class_id);
- term_printf(" USB device %04x:%04x", vendor_id, product_id);
+ monitor_printf(mon, " Class %02x:", class_id);
+ monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
if (product_name[0] != '\0')
- term_printf(", %s", product_name);
- term_printf("\n");
+ monitor_printf(mon, ", %s", product_name);
+ monitor_printf(mon, "\n");
}
static int usb_host_info_device(void *opaque, int bus_num, int addr,
@@ -1663,20 +1669,21 @@ static void hex2str(int val, char *str, size_t size)
snprintf(str, size, "%x", val);
}
-void usb_host_info(void)
+void usb_host_info(Monitor *mon)
{
struct USBAutoFilter *f;
usb_host_scan(NULL, usb_host_info_device);
if (usb_auto_filter)
- term_printf(" Auto filters:\n");
+ monitor_printf(mon, " Auto filters:\n");
for (f = usb_auto_filter; f; f = f->next) {
char bus[10], addr[10], vid[10], pid[10];
dec2str(f->bus_num, bus, sizeof(bus));
dec2str(f->addr, addr, sizeof(addr));
hex2str(f->vendor_id, vid, sizeof(vid));
hex2str(f->product_id, pid, sizeof(pid));
- term_printf(" Device %s.%s ID %s:%s\n", bus, addr, vid, pid);
+ monitor_printf(mon, " Device %s.%s ID %s:%s\n",
+ bus, addr, vid, pid);
}
}
diff --git a/usb-stub.c b/usb-stub.c
index 52105c3..9c3fcea 100644
--- a/usb-stub.c
+++ b/usb-stub.c
@@ -33,10 +33,11 @@
#include "qemu-common.h"
#include "console.h"
#include "hw/usb.h"
+#include "monitor.h"
-void usb_host_info(void)
+void usb_host_info(Monitor *mon)
{
- term_printf("USB host devices not supported\n");
+ monitor_printf(mon, "USB host devices not supported\n");
}
/* XXX: modify configure to compile the right host driver */
diff --git a/vl.c b/vl.c
index 6c0adb5..307d884 100644
--- a/vl.c
+++ b/vl.c
@@ -31,6 +31,7 @@
#include "hw/baum.h"
#include "hw/bt.h"
#include "net.h"
+#include "monitor.h"
#include "console.h"
#include "sysemu.h"
#include "gdbstub.h"
@@ -653,34 +654,34 @@ int kbd_mouse_is_absolute(void)
return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
}
-void do_info_mice(void)
+void do_info_mice(Monitor *mon)
{
QEMUPutMouseEntry *cursor;
int index = 0;
if (!qemu_put_mouse_event_head) {
- term_printf("No mouse devices connected\n");
+ monitor_printf(mon, "No mouse devices connected\n");
return;
}
- term_printf("Mouse devices available:\n");
+ monitor_printf(mon, "Mouse devices available:\n");
cursor = qemu_put_mouse_event_head;
while (cursor != NULL) {
- term_printf("%c Mouse #%d: %s\n",
- (cursor == qemu_put_mouse_event_current ? '*' : ' '),
- index, cursor->qemu_put_mouse_event_name);
+ monitor_printf(mon, "%c Mouse #%d: %s\n",
+ (cursor == qemu_put_mouse_event_current ? '*' : ' '),
+ index, cursor->qemu_put_mouse_event_name);
index++;
cursor = cursor->next;
}
}
-void do_mouse_set(int index)
+void do_mouse_set(Monitor *mon, int index)
{
QEMUPutMouseEntry *cursor;
int i = 0;
if (!qemu_put_mouse_event_head) {
- term_printf("No mouse devices connected\n");
+ monitor_printf(mon, "No mouse devices connected\n");
return;
}
@@ -693,7 +694,7 @@ void do_mouse_set(int index)
if (cursor != NULL)
qemu_put_mouse_event_current = cursor;
else
- term_printf("Mouse at given index not found\n");
+ monitor_printf(mon, "Mouse at given index not found\n");
}
/* compute with 96 bit intermediate result: (a*b)/c */
@@ -2697,7 +2698,8 @@ static int usb_device_add(const char *devname, int is_hotplug)
if (bdrv_key_required(bs)) {
autostart = 0;
if (is_hotplug) {
- monitor_read_bdrv_key_start(bs, usb_msd_password_cb, dev);
+ monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb,
+ dev);
return 0;
}
}
@@ -2779,24 +2781,24 @@ static int usb_device_del(const char *devname)
return usb_device_del_addr(bus_num, addr);
}
-void do_usb_add(const char *devname)
+void do_usb_add(Monitor *mon, const char *devname)
{
usb_device_add(devname, 1);
}
-void do_usb_del(const char *devname)
+void do_usb_del(Monitor *mon, const char *devname)
{
usb_device_del(devname);
}
-void usb_info(void)
+void usb_info(Monitor *mon)
{
USBDevice *dev;
USBPort *port;
const char *speed_str;
if (!usb_enabled) {
- term_printf("USB support not enabled\n");
+ monitor_printf(mon, "USB support not enabled\n");
return;
}
@@ -2818,8 +2820,8 @@ void usb_info(void)
speed_str = "?";
break;
}
- term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
- 0, dev->addr, speed_str, dev->devname);
+ monitor_printf(mon, " Device %d.%d, Speed %s Mb/s, Product %s\n",
+ 0, dev->addr, speed_str, dev->devname);
}
}
@@ -2853,16 +2855,17 @@ void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
}
}
-void pcmcia_info(void)
+void pcmcia_info(Monitor *mon)
{
struct pcmcia_socket_entry_s *iter;
+
if (!pcmcia_sockets)
- term_printf("No PCMCIA sockets\n");
+ monitor_printf(mon, "No PCMCIA sockets\n");
for (iter = pcmcia_sockets; iter; iter = iter->next)
- term_printf("%s: %s\n", iter->socket->slot_string,
- iter->socket->attached ? iter->socket->card_string :
- "Empty");
+ monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
+ iter->socket->attached ? iter->socket->card_string :
+ "Empty");
}
/***********************************************************/
@@ -5726,7 +5729,7 @@ int main(int argc, char **argv, char **envp)
#endif
if (loadvm)
- do_loadvm(loadvm);
+ do_loadvm(cur_mon, loadvm);
if (incoming) {
autostart = 0; /* fixme how to deal with -daemonize */
diff --git a/vnc.c b/vnc.c
index 81c842a..67cec07 100644
--- a/vnc.c
+++ b/vnc.c
@@ -24,6 +24,7 @@
*/
#include "qemu-common.h"
+#include "monitor.h"
#include "console.h"
#include "sysemu.h"
#include "qemu_socket.h"
@@ -166,19 +167,19 @@ struct VncState
static VncDisplay *vnc_display; /* needed for info vnc */
static DisplayChangeListener *dcl;
-void do_info_vnc(void)
+void do_info_vnc(Monitor *mon)
{
if (vnc_display == NULL || vnc_display->display == NULL)
- term_printf("VNC server disabled\n");
+ monitor_printf(mon, "VNC server disabled\n");
else {
- term_printf("VNC server active on: ");
- term_print_filename(vnc_display->display);
- term_printf("\n");
+ monitor_printf(mon, "VNC server active on: ");
+ monitor_print_filename(mon, vnc_display->display);
+ monitor_printf(mon, "\n");
if (vnc_display->clients == NULL)
- term_printf("No client connected\n");
+ monitor_printf(mon, "No client connected\n");
else
- term_printf("Client connected\n");
+ monitor_printf(mon, "Client connected\n");
}
}
@@ -807,10 +808,11 @@ static void audio_capture(void *opaque, void *buf, int size)
static void audio_add(VncState *vs)
{
+ Monitor *mon = cur_mon;
struct audio_capture_ops ops;
if (vs->audio_cap) {
- term_printf ("audio already running\n");
+ monitor_printf(mon, "audio already running\n");
return;
}
@@ -820,7 +822,7 @@ static void audio_add(VncState *vs)
vs->audio_cap = AUD_add_capture(NULL, &vs->as, &ops, vs);
if (!vs->audio_cap) {
- term_printf ("Failed to add audio capture\n");
+ monitor_printf(mon, "Failed to add audio capture\n");
}
}