break;
} else if (*pacb == acb) {
*pacb = acb->next;
- raw_fd_pool_put(acb);
qemu_aio_release(acb);
break;
}
bigendian="no"
mingw32="no"
EXESUF=""
-gdbstub="yes"
+gdbstub="no"
slirp="yes"
vde="yes"
fmod_lib=""
typedef void CPUWriteMemoryFunc(void *opaque, target_phys_addr_t addr, uint32_t value);
typedef uint32_t CPUReadMemoryFunc(void *opaque, target_phys_addr_t addr);
+#ifdef CONFIG_DM
+void cpu_register_physical_memory(target_phys_addr_t start_addr,
+ ram_addr_t size,
+ ram_addr_t phys_offset);
+#else
void cpu_register_physical_memory_offset(target_phys_addr_t start_addr,
ram_addr_t size,
ram_addr_t phys_offset,
{
cpu_register_physical_memory_offset(start_addr, size, phys_offset, 0);
}
+#endif
ram_addr_t cpu_get_physical_page_desc(target_phys_addr_t addr);
ram_addr_t qemu_ram_alloc(ram_addr_t);
#include "pci.h"
#include "console.h"
#include "vga_int.h"
-#include "kvm.h"
+#include "qemu-xen.h"
+#include "qemu-log.h"
/*
* TODO:
static void cirrus_bitblt_reset(CirrusVGAState *s);
static void cirrus_update_memory_access(CirrusVGAState *s);
+static void cirrus_vga_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val);
/***************************************
*
}
if (limit > 0) {
- /* Thinking about changing bank base? First, drop the dirty bitmap information
- * on the current location, otherwise we lose this pointer forever */
- if (s->lfb_vram_mapped) {
- target_phys_addr_t base_addr = isa_mem_base + 0xa0000 + bank_index * 0x8000;
- cpu_physical_sync_dirty_bitmap(base_addr, base_addr + 0x8000);
- }
s->cirrus_bank_base[bank_index] = offset;
s->cirrus_bank_limit[bank_index] = limit;
} else {
s->hw_cursor_y = (reg_value << 3) | (reg_index >> 5);
break;
case 0x07: // Extended Sequencer Mode
- cirrus_update_memory_access(s);
case 0x08: // EEPROM Control
case 0x09: // Scratch Register 0
case 0x0a: // Scratch Register 1
cirrus_vga_mem_writew(s, addr, (reg_value << 8) | s->gr[0xFE]);
}
break;
- default:
default:
#ifdef DEBUG_CIRRUS
s->gr[reg_index] = reg_value;
cirrus_update_bank_ptr(s, 0);
cirrus_update_bank_ptr(s, 1);
- cirrus_update_memory_access(s);
break;
case 0x0B:
s->gr[reg_index] = reg_value;
cirrus_linear_bitblt_writel,
};
-static void map_linear_vram(CirrusVGAState *s)
-{
- if (s->lfb_addr && s->lfb_end && s->vram_gmfn != s->lfb_addr) {
- set_vram_mapping(s, s->lfb_addr, s->lfb_end);
- }
- vga_dirty_log_stop((VGAState *)s);
-
- if (!s->map_addr && s->lfb_addr && s->lfb_end) {
- s->map_addr = s->lfb_addr;
- s->map_end = s->lfb_end;
- cpu_register_physical_memory(s->map_addr, s->map_end - s->map_addr, s->vram_offset);
- }
-
- if (!s->map_addr)
- return;
-
- s->lfb_vram_mapped = 0;
-
- if (!(s->cirrus_srcptr != s->cirrus_srcptr_end)
- && !((s->sr[0x07] & 0x01) == 0)
- && !((s->gr[0x0B] & 0x14) == 0x14)
- && !(s->gr[0x0B] & 0x02)) {
-
- cpu_register_physical_memory(isa_mem_base + 0xa0000, 0x8000,
- (s->vram_offset + s->cirrus_bank_base[0]) | IO_MEM_RAM);
- cpu_register_physical_memory(isa_mem_base + 0xa8000, 0x8000,
- (s->vram_offset + s->cirrus_bank_base[1]) | IO_MEM_RAM);
-
- s->lfb_vram_mapped = 1;
- }
- else {
- cpu_register_physical_memory(isa_mem_base + 0xa0000, 0x20000,
- s->vga_io_memory);
- }
-
- vga_dirty_log_start((VGAState *)s);
-}
-
-static void unmap_linear_vram(CirrusVGAState *s)
-{
- if (s->lfb_addr && s->lfb_end && s->vram_gmfn != s->lfb_addr) {
- unset_vram_mapping(s);
- }
- vga_dirty_log_stop((VGAState *)s);
-
- if (s->map_addr && s->lfb_addr && s->lfb_end)
- s->map_addr = s->map_end = 0;
-
- cpu_register_physical_memory(isa_mem_base + 0xa0000, 0x20000,
- s->vga_io_memory);
-
- vga_dirty_log_start((VGAState *)s);
-}
-
/* Compute the memory access functions */
static void cirrus_update_memory_access(CirrusVGAState *s)
{
mode = s->gr[0x05] & 0x7;
if (mode < 4 || mode > 5 || ((s->gr[0x0B] & 0x4) == 0)) {
- map_linear_vram(s);
+ if (s->lfb_addr && s->lfb_end && s->vram_gmfn != s->lfb_addr) {
+ set_vram_mapping(s, s->lfb_addr, s->lfb_end);
+ }
s->cirrus_linear_write[0] = cirrus_linear_mem_writeb;
s->cirrus_linear_write[1] = cirrus_linear_mem_writew;
s->cirrus_linear_write[2] = cirrus_linear_mem_writel;
} else {
generic_io:
- unmap_linear_vram(s);
+ if (s->lfb_addr && s->lfb_end && s->vram_gmfn != s->lfb_addr) {
+ unset_vram_mapping(s);
+ }
s->cirrus_linear_write[0] = cirrus_linear_writeb;
s->cirrus_linear_write[1] = cirrus_linear_writew;
s->cirrus_linear_write[2] = cirrus_linear_writel;
/* XXX: we do not save the bitblt state - we assume we do not save
the state when the blitter is active */
- vga_acc = (s->lfb_addr == s->vram_gmfn);
+ uint8_t vga_acc = (s->lfb_addr == s->vram_gmfn);
qemu_put_8s(f, &vga_acc);
/* XXX old versions saved rubbish here, keeping for compatibility */
qemu_put_be32(f, 0xffffffff);
if (version_id >= 3)
qemu_get_be64s(f, &s->vram_gmfn);
- t = s->vram_gmfn;
+ uint64_t t = s->vram_gmfn;
if (!s->vram_gmfn) {
/* Old guest, VRAM is not mapped, we have to restore it
* ourselves */
if (version_id < 3 || (!vga_acc && !t))
qemu_get_buffer(f, s->vram_ptr, s->vram_size);
- cirrus_update_memory_access(s);
/* force refresh */
s->graphic_mode = -1;
cirrus_update_bank_ptr(s, 0);
{
CirrusVGAState *s = opaque;
- vga_reset(s);
- unmap_linear_vram(s);
+ memset(s, 0, sizeof(*s));
+ s->graphic_mode = -1; /* force full update */
+
s->sr[0x06] = 0x0f;
if (s->device_id == CIRRUS_ID_CLGD5446) {
/* 4MB 64 bit memory config, always PCI */
register_ioport_read(0x3ba, 1, 1, vga_ioport_read, s);
register_ioport_read(0x3da, 1, 1, vga_ioport_read, s);
- s->vga_io_memory = cpu_register_io_memory(0, cirrus_vga_mem_read,
+ int vga_io_memory = cpu_register_io_memory(0, cirrus_vga_mem_read,
cirrus_vga_mem_write, s);
cpu_register_physical_memory(isa_mem_base + 0x000a0000, 0x20000,
- s->vga_io_memory);
+ vga_io_memory);
qemu_register_coalesced_mmio(isa_mem_base + 0x000a0000, 0x20000);
/* I/O handler for LFB */
cpu_register_physical_memory(addr + 0x1000000, 0x400000,
s->cirrus_linear_bitblt_io_addr);
-
- s->map_addr = s->map_end = 0;
- s->lfb_addr = addr & TARGET_PAGE_MASK;
- s->lfb_end = ((addr + VGA_RAM_SIZE) + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK;
- /* account for overflow */
- if (s->lfb_end < addr + VGA_RAM_SIZE)
- s->lfb_end = addr + VGA_RAM_SIZE;
-
vga_dirty_log_start((VGAState *)s);
}
s->cirrus_mmio_io_addr);
}
-static void pci_cirrus_write_config(PCIDevice *d,
- uint32_t address, uint32_t val, int len)
-{
- PCICirrusVGAState *pvs = container_of(d, PCICirrusVGAState, dev);
- CirrusVGAState *s = &pvs->cirrus_vga;
-
- vga_dirty_log_stop((VGAState *)s);
-
- pci_default_write_config(d, address, val, len);
- if (s->map_addr && pvs->dev.io_regions[0].addr == -1)
- s->map_addr = 0;
- cirrus_update_memory_access(s);
-
- vga_dirty_log_start((VGAState *)s);
-}
-
void pci_cirrus_vga_init(PCIBus *bus, uint8_t *vga_ram_base,
ram_addr_t vga_ram_offset, int vga_ram_size)
{
/* setup PCI configuration registers */
d = (PCICirrusVGAState *)pci_register_device(bus, "Cirrus VGA",
sizeof(PCICirrusVGAState),
- -1, NULL, pci_cirrus_write_config);
+ -1, NULL, NULL);
pci_conf = d->dev.config;
pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_CIRRUS);
pci_config_set_device_id(pci_conf, device_id);
int64_t next_periodic_time;
/* second update */
int64_t next_second_time;
-#ifdef TARGET_I386
+#ifdef IRQ_COALESCE_HACK
uint32_t irq_coalesced;
uint32_t period;
#endif
period_code += 7;
/* period in 32 Khz cycles */
period = 1 << (period_code - 1);
-#ifdef TARGET_I386
+#ifdef IRQ_COALESCE_HACK
if(period != s->period)
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
s->period = period;
s->next_periodic_time = muldiv64(next_irq_clock, ticks_per_sec, 32768) + 1;
qemu_mod_timer(s->periodic_timer, s->next_periodic_time);
} else {
-#ifdef TARGET_I386
+#ifdef IRQ_COALESCE_HACK
s->irq_coalesced = 0;
#endif
qemu_del_timer(s->periodic_timer);
RTCState *s = opaque;
rtc_timer_update(s, s->next_periodic_time);
-#ifdef TARGET_I386
+#ifdef IRQ_COALESCE_HACK
if ((s->cmos_data[RTC_REG_C] & 0xc0) && rtc_td_hack) {
s->irq_coalesced++;
return;
case RTC_REG_C:
ret = s->cmos_data[s->cmos_index];
qemu_irq_lower(s->irq);
-#ifdef TARGET_I386
+#ifdef IRQ_COALESCE_HACK
if(s->irq_coalesced) {
apic_reset_irq_delivered();
qemu_irq_raise(s->irq);
return 0;
}
-#ifdef TARGET_I386
+#ifdef IRQ_COALESCE_HACK
static void rtc_save_td(QEMUFile *f, void *opaque)
{
RTCState *s = opaque;
register_ioport_read(base, 2, 1, cmos_ioport_read, s);
register_savevm("mc146818rtc", base, 1, rtc_save, rtc_load, s);
-#ifdef TARGET_I386
+#ifdef IRQ_COALESCE_HACK
if (rtc_td_hack)
register_savevm("mc146818rtc-td", base, 1, rtc_save_td, rtc_load_td, s);
#endif
cpu_register_physical_memory(base, 2 << it_shift, io_memory);
register_savevm("mc146818rtc", base, 1, rtc_save, rtc_load, s);
-#ifdef TARGET_I386
+#ifdef IRQ_COALESCE_HACK
if (rtc_td_hack)
register_savevm("mc146818rtc-td", base, 1, rtc_save_td, rtc_load_td, s);
#endif
isa_cirrus_vga_init(phys_ram_base + vga_ram_addr,
vga_ram_addr, vga_ram_size);
}
+#ifndef CONFIG_DM
} else if (vmsvga_enabled) {
if (pci_enabled)
pci_vmsvga_init(pci_bus, phys_ram_base + vga_ram_addr,
vga_ram_addr, vga_ram_size);
else
fprintf(stderr, "%s: vmware_vga: no PCI bus\n", __FUNCTION__);
+#endif
} else if (std_vga_enabled) {
if (pci_enabled) {
pci_vga_init(pci_bus, phys_ram_base + vga_ram_addr,
}
}
+#ifndef CONFIG_DM
/* Add virtio block devices */
if (pci_enabled) {
int index;
virtio_console_init(pci_bus, virtcon_hds[i]);
}
}
+#endif
}
static void pc_init_pci(ram_addr_t ram_size, int vga_ram_size,
rtc_set_memory(rtc_state, 0xF, 0xFE);
}
-/* set CMOS shutdown status register (index 0xF) as S3_resume(0xFE)
- BIOS will read it and start S3 resume at POST Entry */
-void cmos_set_s3_resume(void)
-{
- if (rtc_state)
- rtc_set_memory(rtc_state, 0xF, 0xFE);
-}
-
QEMUMachine pc_machine = {
.name = "pc",
.desc = "Standard PC",
void ioport_set_a20(int enable);
int ioport_get_a20(void);
-void cmos_set_s3_resume(void);
/* acpi.c */
extern int acpi_enabled;
#define VGA_RAM_SIZE (9 * 1024 * 1024)
#endif
-int isa_vga_init(DisplayState *ds, uint8_t *vga_ram_base,
+int isa_vga_init(uint8_t *vga_ram_base,
unsigned long vga_ram_offset, int vga_ram_size);
int pci_vga_init(PCIBus *bus, uint8_t *vga_ram_base,
unsigned long vga_ram_offset, int vga_ram_size,
"i82557b",
"i82559er",
"rtl8139",
- "e100",
"e1000",
"pcnet",
"virtio",
pci_i82557b_init,
pci_i82559er_init,
pci_rtl8139_init,
- pci_e100_init,
pci_e1000_init,
pci_pcnet_init,
virtio_net_init,
}
/* do the same job as vgabios before vgabios get ready - yeah */
-void vga_bios_init(VGAState *s)
+static void vga_bios_init(VGAState *s)
{
uint8_t palette_model[192] = {
0, 0, 0, 0, 0, 170, 0, 170,
#include "pci.h"
#include "irq.h"
#include "qemu-xen.h"
+#include "net.h"
#include <assert.h>
#include <xenguest.h>
uint8_t max_lat;
};
-void xen_pci_save(QEMUFile *f, void *opaque)
+static void xen_pci_save(QEMUFile *f, void *opaque)
{
PCIXenPlatformState *d = opaque;
uint64_t t = 0;
qemu_put_be64s(f, &t);
}
-int xen_pci_load(QEMUFile *f, void *opaque, int version_id)
+static int xen_pci_load(QEMUFile *f, void *opaque, int version_id)
{
PCIXenPlatformState *d = opaque;
int ret;
#define TARGET_I386 1
#define CONFIG_SOFTMMU 1
#define CONFIG_SOFTFLOAT 1
-#define CONFIG_DM 1
void cpu_set_ferr(CPUX86State *s);
void cpu_x86_set_a20(CPUX86State *env, int a20_state);
+uint64_t cpu_get_tsc(CPUX86State *env);
/* used to debug */
#define X86_DUMP_FPU 0x0001 /* dump FPU state too */
#include <inttypes.h>
#include "cpu.h"
+#include "cpu-all.h"
#include "exec-all.h"
#include "hw.h"
+#include "pc.h"
+#include "disas.h"
#include "qemu-xen.h"
//#define DEBUG_TB_INVALIDATE
page size. If (phys_offset & ~TARGET_PAGE_MASK) != 0, then it is an
io memory page */
void cpu_register_physical_memory(target_phys_addr_t start_addr,
- unsigned long size,
- unsigned long phys_offset)
+ ram_addr_t size,
+ ram_addr_t phys_offset)
{
int i;
}
#else
-int iomem_index(target_phys_addr_t addr)
+static int iomem_index(target_phys_addr_t addr)
{
int i;
{
int index = iomem_index(start);
if (index) {
- fprintf(logfile, "squash iomem [%lx, %lx).\n", mmio[index].start,
- mmio[index].start + mmio[index].size);
+ fprintf(logfile, "squash iomem [%lx, %lx).\n",
+ (unsigned long)(mmio[index].start),
+ (unsigned long)(mmio[index].start + mmio[index].size));
mmio[index].start = mmio[index].size = 0;
}
}
return cpu_physical_memory_write(addr,buf,len);
}
+void qemu_register_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size) { }
+void qemu_unregister_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size) { }
+
+
+void *cpu_physical_memory_map(target_phys_addr_t addr,
+ target_phys_addr_t *plen,
+ int is_write) {
+ xen_pfn_t first, last, count, i;
+ target_phys_addr_t offset;
+ void *vaddr;
+
+ if (!*plen)
+ return NULL;
+
+ first = addr >> XC_PAGE_SHIFT;
+ last = (addr + *plen - 1) >> XC_PAGE_SHIFT;
+ count = last - first + 1;
+ offset = addr & (XC_PAGE_SIZE-1);
+
+ xen_pfn_t pfns[count];
+
+ for (i = 0; i < count; i++)
+ pfns[i] = first + i;
+
+ vaddr = xc_map_foreign_batch(xc_handle, domid,
+ is_write ? PROT_WRITE : PROT_READ,
+ pfns, count);
+ if (!vaddr)
+ perror("cpu_physical_memory_map: map failed");
+
+ return vaddr;
+}
+
+void cpu_physical_memory_unmap(void *buffer, target_phys_addr_t len,
+ int is_write, target_phys_addr_t access_len) {
+ uintptr_t start, end;
+ int ret;
+
+ if (!len) return;
+
+ start = (uintptr_t)buffer & (XC_PAGE_SIZE - 1);
+ end = ((uintptr_t)(buffer + len - 1) | (XC_PAGE_SIZE - 1)) + 1;
+
+ ret = munmap((void*)start, end - start);
+ if (ret)
+ perror("cpu_physical_memory_unmap: munmap failed");
+}
+
+void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque)) {
+ return 0;
+}
+void cpu_unregister_map_client(void *cookie) {
+}
+
/* stub out various functions for Xen DM */
void dump_exec_info(FILE *f,
int (*cpu_fprintf)(FILE *f, const char *fmt, ...)) {
static VLANState *first_vlan;
-static TAPState *head_net_tap;
-
-void net_tap_shutdown_all(void)
-{
- struct IOHandlerRecord **pioh, *ioh;
-
- while (head_net_tap) {
- qemu_set_fd_handler2(head_net_tap->fd, 0,0,0,0);
- close(head_net_tap->fd);
- head_net_tap = head_net_tap->next;
- }
-}
+static struct TAPState *head_net_tap;
/***********************************************************/
/* network device redirectors */
}
if (get_param_value(script_arg, sizeof(script_arg), "scriptarg", p) == 0 &&
get_param_value(script_arg, sizeof(script_arg), "bridge", p) == 0) { /* deprecated; for xend compatibility */
-+ pstrcpy(script_arg, sizeof(script_arg), "");
+ pstrcpy(script_arg, sizeof(script_arg), "");
}
ret = net_tap_init(vlan, device, name, ifname, setup_script, down_script, script_arg);
}
TAPState *s = vc->opaque;
if (s->down_script[0])
- launch_script(s->down_script, s->down_script_arg, s->fd);
+ launch_script(s->down_script, s->down_script_arg,
+ s->script_arg, s->fd);
}
#if defined(CONFIG_VDE)
if (vc->fd_read == vde_from_qemu) {
vlan->id);
}
}
+
+void net_tap_shutdown_all(void)
+{
+ struct IOHandlerRecord **pioh, *ioh;
+
+ while (head_net_tap) {
+ qemu_set_fd_handler2(head_net_tap->fd, 0,0,0,0);
+ close(head_net_tap->fd);
+ head_net_tap = head_net_tap->next;
+ }
+}
void net_cleanup(void);
int slirp_is_inited(void);
void net_client_check(void);
+void net_tap_shutdown_all(void);
#ifndef DEFAULT_NETWORK_SCRIPT
#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
void unset_vram_mapping(void *opaque);
#endif
-void ide_unplug_harddisks(void);
-void net_tap_shutdown_all(void);
void pci_unplug_netifs(void);
void destroy_hvm_domain(void);
void unregister_iomem(target_phys_addr_t start);
int has_tpm_device_danger(void);
+static void vga_dirty_log_start(void *s) { }
+static void vga_dirty_log_stop(void *s) { }
+
#endif /*QEMU_XEN_H*/
int fread_targphys(target_phys_addr_t dst_addr, size_t nbytes, FILE *f);
int fread_targphys_ok(target_phys_addr_t dst_addr, size_t nbytes, FILE *f);
int read_targphys(int fd, target_phys_addr_t dst_addr, size_t nbytes);
+void pstrcpy_targphys(target_phys_addr_t dest, int buf_size,
+ const char *source);
#endif
#ifdef HAS_AUDIO
#include "kvm.h"
#include "balloon.h"
+#include "hw/pci.h"
+#include "hw/xen.h"
+#include <stdlib.h>
+
+#include "qemu-xen.h"
+
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
to store the VM snapshots */
DriveInfo drives_table[MAX_DRIVES+1];
int nb_drives;
-static int vga_ram_size;
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
+int vga_ram_size;
static DisplayState *display_state;
int nographic;
static int curses;
uint8_t qemu_uuid[16];
+#include "xen-vl-extra.c"
+
/***********************************************************/
/* x86 ISA bus support */
fprintf(stderr, "\n");
for(env = first_cpu; env != NULL; env = env->next_cpu) {
fprintf(stderr, "CPU #%d:\n", env->cpu_index);
-#ifdef TARGET_I386
+#if defined(TARGET_I386) && !defined(CONFIG_DM)
cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
#else
cpu_dump_state(env, stderr, fprintf, 0);
static int unix_start_timer(struct qemu_alarm_timer *t);
static void unix_stop_timer(struct qemu_alarm_timer *t);
-#ifdef __linux__
+#if defined(__linux__) && !defined(CONFIG_DM)
static int dynticks_start_timer(struct qemu_alarm_timer *t);
static void dynticks_stop_timer(struct qemu_alarm_timer *t);
static struct qemu_alarm_timer alarm_timers[] = {
#ifndef _WIN32
-#ifdef __linux__
+#if defined(__linux__) && !defined(CONFIG_DM)
{"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
dynticks_stop_timer, dynticks_rearm_timer, NULL},
/* HPET - if available - is preferred */
}
}
+void qemu_advance_timer(QEMUTimer *ts, int64_t expire_time)
+{
+ if (ts->expire_time > expire_time)
+ qemu_mod_timer(ts, expire_time);
+}
+
/* modify the current timer so that it will be fired when current_time
>= expire_time. The corresponding callback will be called. */
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
}
}
+/* run the specified timer */
+void qemu_run_one_timer(QEMUTimer *ts)
+{
+ uint64_t current_time;
+
+ /* remove timer from the list before calling the callback */
+ qemu_del_timer(ts);
+
+ while ((current_time = qemu_get_clock(rt_clock)) < ts->expire_time)
+ /* sleep until the expire time */
+ usleep((ts->expire_time - current_time) * 1000);
+
+ /* run the callback */
+ ts->cb(ts->opaque);
+}
+
static void timer_save(QEMUFile *f, void *opaque)
{
if (cpu_ticks_enabled) {
hw_error("cannot save state if virtual timers are running");
}
+#ifndef CONFIG_DM
qemu_put_be64(f, cpu_ticks_offset);
qemu_put_be64(f, ticks_per_sec);
+#endif
qemu_put_be64(f, cpu_clock_offset);
}
if (cpu_ticks_enabled) {
return -EINVAL;
}
+#ifndef CONFIG_DM
cpu_ticks_offset=qemu_get_be64(f);
ticks_per_sec=qemu_get_be64(f);
if (version_id == 2) {
+#else
+ if (version_id == 1 || version_id == 2) {
+#endif
cpu_clock_offset=qemu_get_be64(f);
}
return 0;
}
+#ifndef CONFIG_DM /* ends just before fcntl_setfl */
#ifdef _WIN32
void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
return delta;
}
#endif
+#endif
#ifndef _WIN32
return 0;
}
+#ifndef CONFIG_DM /* ends after end of win32_rearm_timer */
#if defined(__linux__)
#define RTC_FREQ 1024
}
#endif /* _WIN32 */
+#endif /* !CONFIG_DM */
static int init_timer_alarm(void)
{
case IF_MTD:
case IF_VIRTIO:
break;
+ case IF_BLKTAP:
+ abort();
}
if (!file[0])
return 0;
/***********************************************************/
/* ram save/restore */
+#ifdef CONFIG_DM
+static int ram_save_live(QEMUFile *f, int stage, void *opaque) { return 1; }
+static int ram_load(QEMUFile *f, void *opaque, int version_id) { return 0; }
+#else /* !CONFIG_DM */
+
static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
{
int v;
return 0;
}
+#endif /* !CONFIG_DM */
+
void qemu_service_io(void)
{
CPUState *env = cpu_single_env;
}
-static int main_loop(void)
+#ifndef CONFIG_DM
+
+int main_loop(void)
{
int ret, timeout;
#ifdef CONFIG_PROFILER
return ret;
}
+#else /* CONFIG_DM */
+void main_loop_prepare(void) {
+ cur_cpu = first_cpu;
+}
+#endif /* !CONFIG_DM */
+
static void help(int exitcode)
{
/* Please keep in synch with QEMU_OPTION_ enums, qemu_options[]
"-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
"-no-quit disable SDL window close capability\n"
"-sdl enable SDL\n"
+#ifdef CONFIG_OPENGL
+ "-disable-opengl disable OpenGL rendering, using SDL"
+#endif
#endif
"-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
"-vga [std|cirrus|vmware|none]\n"
"-net tap[,vlan=n][,name=str],ifname=name\n"
" connect the host TAP network interface to VLAN 'n'\n"
#else
- "-net tap[,vlan=n][,name=str][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
+ "-net tap[,vlan=n][,name=str][,fd=h][,ifname=name][,script=file][,downscript=dfile][,scriptarg=extraargument]\n"
" connect the host TAP network interface to VLAN 'n' and use the\n"
" network scripts 'file' (default=%s)\n"
" and 'dfile' (default=%s);\n"
" use '[down]script=no' to disable script execution;\n"
+ " use 'scriptarg=...' to pass an additional (nonempty) argument;\n"
" use 'fd=h' to connect to an already opened TAP interface\n"
#endif
"-net socket[,vlan=n][,name=str][,fd=h][,listen=[host]:port][,connect=host:port]\n"
"-tb-size n set TB size\n"
"-incoming p prepare for incoming migration, listen on port p\n"
"\n"
+ "Options specific to the Xen version:\n"
+ "-videoram set amount of memory available to virtual video adapter\n"
+ "-direct-pci s specify pci passthrough, with configuration string s\n"
+ "-pciemulation name:vendorid:deviceid:command:status:revision:classcode:headertype:subvendorid:subsystemid:interruputline:interruputpin\n"
+ "-vncunused bind the VNC server to an unused port\n"
+ "-std-vga alias for -vga std\n"
+ "\n"
"During emulation, the following keys are useful:\n"
"ctrl-alt-f toggle full screen\n"
"ctrl-alt-n switch to virtual console 'n'\n"
QEMU_OPTION_append,
QEMU_OPTION_initrd,
+ /* Xen tree: */
+ QEMU_OPTION_disable_opengl,
+ QEMU_OPTION_direct_pci,
+ QEMU_OPTION_pci_emulation,
+ QEMU_OPTION_vncunused,
+ QEMU_OPTION_videoram,
+ QEMU_OPTION_std_vga,
+ QEMU_OPTION_domid,
+ QEMU_OPTION_domainname,
+ QEMU_OPTION_acpi,
+ QEMU_OPTION_vcpus,
+
/* Debug/Expert options: */
QEMU_OPTION_serial,
QEMU_OPTION_parallel,
#if defined(TARGET_ARM) || defined(TARGET_M68K)
{ "semihosting", 0, QEMU_OPTION_semihosting },
#endif
+
+ /* Xen tree options: */
+ { "std-vga", 0, QEMU_OPTION_std_vga },
+ { "videoram", HAS_ARG, QEMU_OPTION_videoram },
+ { "d", HAS_ARG, QEMU_OPTION_domid }, /* deprecated; for xend compatibility */
+ { "domid", HAS_ARG, QEMU_OPTION_domid },
+ { "domain-name", 1, QEMU_OPTION_domainname },
+#ifdef CONFIG_OPENGL
+ { "disable-opengl", 0, QEMU_OPTION_disable_opengl },
+#endif
+ { "acpi", 0, QEMU_OPTION_acpi }, /* deprecated, for xend compatibility */
+ { "direct_pci", HAS_ARG, QEMU_OPTION_direct_pci },
+ { "pciemulation", HAS_ARG, QEMU_OPTION_pci_emulation },
+ { "vncunused", 0, QEMU_OPTION_vncunused },
+ { "vcpus", 0, QEMU_OPTION_vcpus },
+#ifdef CONFIG_XEN
+ { "xen-domid", HAS_ARG, QEMU_OPTION_xen_domid },
+ { "xen-create", 0, QEMU_OPTION_xen_create },
+ { "xen-attach", 0, QEMU_OPTION_xen_attach },
+#endif
+
#if defined(TARGET_ARM)
{ "old-param", 0, QEMU_OPTION_old_param },
#endif
#ifdef HAS_AUDIO
struct soundhw soundhw[] = {
#ifdef HAS_AUDIO_CHOICE
-#if defined(TARGET_I386) || defined(TARGET_MIPS)
+#if (defined(TARGET_I386) || defined(TARGET_MIPS)) && !defined(CONFIG_DM)
{
"pcspk",
"PC speaker",
const char *incoming = NULL;
qemu_cache_utils_init(envp);
+ logfile = stderr; /* initial value */
+
+#if !defined(__sun__) && !defined(CONFIG_STUBDOM)
+ struct rlimit rl;
+ /* Maximise rlimits. Needed where default constraints are tight (*BSD). */
+ if (getrlimit(RLIMIT_STACK, &rl) != 0) {
+ perror("getrlimit(RLIMIT_STACK)");
+ exit(1);
+ }
+ rl.rlim_cur = rl.rlim_max;
+ if (setrlimit(RLIMIT_STACK, &rl) != 0)
+ perror("setrlimit(RLIMIT_STACK)");
+ if (getrlimit(RLIMIT_DATA, &rl) != 0) {
+ perror("getrlimit(RLIMIT_DATA)");
+ exit(1);
+ }
+ rl.rlim_cur = rl.rlim_max;
+ if (setrlimit(RLIMIT_DATA, &rl) != 0)
+ perror("setrlimit(RLIMIT_DATA)");
+ rl.rlim_cur = RLIM_INFINITY;
+ rl.rlim_max = RLIM_INFINITY;
+ if (setrlimit(RLIMIT_RSS, &rl) != 0)
+ perror("setrlimit(RLIMIT_RSS)");
+ rl.rlim_cur = RLIM_INFINITY;
+ rl.rlim_max = RLIM_INFINITY;
+ if (setrlimit(RLIMIT_MEMLOCK, &rl) != 0)
+ perror("setrlimit(RLIMIT_MEMLOCK)");
+#endif
LIST_INIT (&vm_change_state_head);
#ifndef _WIN32
machine = first_machine;
cpu_model = NULL;
initrd_filename = NULL;
- ram_size = 0;
- vga_ram_size = VGA_RAM_SIZE;
+ ram_size = VGA_RAM_SIZE;
#ifdef CONFIG_GDBSTUB
use_gdbstub = 0;
gdbstub_port = DEFAULT_GDBSTUB_PORT;
break;
case QEMU_OPTION_loadvm:
loadvm = optarg;
+ restore = 1;
break;
case QEMU_OPTION_full_screen:
full_screen = 1;
sdl = 1;
break;
#endif
+
+ case QEMU_OPTION_pci_emulation:
+ if (nb_pci_emulation >= MAX_PCI_EMULATION) {
+ fprintf(stderr, "Too many PCI emulations\n");
+ exit(1);
+ }
+ pstrcpy(pci_emulation_config_text[nb_pci_emulation],
+ sizeof(pci_emulation_config_text[0]),
+ optarg);
+ nb_pci_emulation++;
+ break;
+ case QEMU_OPTION_domid: /* depricated, use -xen-* instead */
+ xen_domid = domid = atoi(optarg);
+ xen_mode = XEN_ATTACH;
+ fprintf(logfile, "domid: %d\n", domid);
+ break;
+ case QEMU_OPTION_videoram:
+ {
+ char *ptr;
+ vga_ram_size = strtol(optarg,&ptr,10);
+ vga_ram_size *= 1024 * 1024;
+ }
+ break;
+ case QEMU_OPTION_std_vga:
+ cirrus_vga_enabled = 0;
+ vmsvga_enabled = 0;
+ break;
+ case QEMU_OPTION_disable_opengl:
+ opengl_enabled = 0;
+ break;
+ case QEMU_OPTION_direct_pci:
+ direct_pci = optarg;
+ break;
+ case QEMU_OPTION_vcpus:
+ vcpus = atoi(optarg);
+ fprintf(logfile, "qemu: the number of cpus is %d\n", vcpus);
+ break;
+ case QEMU_OPTION_acpi:
+ acpi_enabled = 1;
+ break;
+ case QEMU_OPTION_vncunused:
+ vncunused = 1;
+ break;
+#ifdef CONFIG_XEN
+ case QEMU_OPTION_xen_domid:
+ xen_domid = domid = atoi(optarg);
+ break;
+ case QEMU_OPTION_xen_create:
+ xen_mode = XEN_CREATE;
+ break;
+ case QEMU_OPTION_xen_attach:
+ xen_mode = XEN_ATTACH;
+ break;
+#endif
+
case QEMU_OPTION_pidfile:
pid_file = optarg;
break;
case QEMU_OPTION_semihosting:
semihosting_enabled = 1;
break;
+ case QEMU_OPTION_domainname: /* depricated, use -name instead */
case QEMU_OPTION_name:
+ snprintf(domain_name, sizeof(domain_name),
+ "Xen-%s", optarg);
qemu_name = optarg;
break;
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
}
#endif
+#if defined (__ia64__)
+ if (ram_size > VGA_IO_START)
+ ram_size += VGA_IO_SIZE; /* skip VGA I/O hole */
+ if (ram_size > MMIO_START)
+ ram_size += 1 * MEM_G; /* skip 3G-4G MMIO, LEGACY_IO_SPACE etc. */
+#endif
+
/* init the bluetooth world */
for (i = 0; i < nb_bt_opts; i++)
if (bt_parse(bt_opts[i]))
exit(1);
/* init the memory */
- phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
+
+ /* If we're on cirrus, set vga_ram_size to 4M whatever the videoram option might have set it to */
+ if ( cirrus_vga_enabled && vga_ram_size != 4 * 1024 * 1024 )
+ {
+ fprintf(stderr,"-videoram option does not work with cirrus vga device model. Videoram set to 4M.\n");
+ vga_ram_size = 4 * 1024 * 1024;
+ }
+
+ phys_ram_size = (machine->ram_require + vga_ram_size) & ~RAMSIZE_FIXED;
if (machine->ram_require & RAMSIZE_FIXED) {
if (ram_size > 0) {
phys_ram_size += ram_size;
}
+#ifndef CONFIG_DM
phys_ram_base = qemu_vmalloc(phys_ram_size);
if (!phys_ram_base) {
fprintf(stderr, "Could not allocate physical memory\n");
exit(1);
}
+#endif
/* init the dynamic translator */
cpu_exec_init_all(tb_size * 1024 * 1024);
bdrv_init();
+ xc_handle = xc_interface_open();
+#ifdef CONFIG_STUBDOM
+ {
+ char *domid_s, *msg;
+ if ((msg = xenbus_read(XBT_NIL, "domid", &domid_s)))
+ fprintf(stderr,"Can not read our own domid: %s\n", msg);
+ else
+ xenstore_parse_domain_config(atoi(domid_s));
+ }
+#else
+ xenstore_parse_domain_config(domid);
+#endif /* CONFIG_STUBDOM */
+
/* we always create the cdrom drive, even if no disk is there */
+#ifndef CONFIG_DM
if (nb_drives_opt < MAX_DRIVES)
drive_add(NULL, CDROM_ALIAS);
+#endif
/* we always create at least one floppy */
register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
#ifndef _WIN32
+#ifndef CONFIG_DM
/* must be after terminal init, SDL library changes signal handlers */
termsig_setup();
+#endif
#endif
/* Maintain compatibility with multiple stdio monitors */
}
machine->init(ram_size, vga_ram_size, boot_devices,
- kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
+ kernel_filename, kernel_cmdline, initrd_filename, cpu_model,
+ direct_pci);
/* Set KVM's vcpu state to qemu's initial CPUState. */
if (kvm_enabled()) {
/* just use the first displaystate for the moment */
ds = display_state;
/* terminal init */
+#ifdef CONFIG_STUBDOM
+ if (xenfb_pv_display_init(ds) == 0) {
+ } else
+#endif
if (nographic) {
if (curses) {
fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
} else
#endif
{
- if (vnc_display != NULL) {
+ if (vnc_display != NULL || vncunused != 0) {
+ int vnc_display_port;
+ char password[20];
vnc_display_init(ds);
- if (vnc_display_open(ds, vnc_display) < 0)
+ xenstore_read_vncpasswd(domid, password, sizeof(password));
+ vnc_display_password(ds, password);
+ vnc_display_port = vnc_display_open(ds, vnc_display, vncunused);
+ if (vnc_display_port < 0)
exit(1);
+ xenstore_write_vncport(vnc_display_port);
}
#if defined(CONFIG_SDL)
if (sdl || !vnc_display)
- sdl_display_init(ds, full_screen, no_frame);
+ sdl_display_init(ds, full_screen, no_frame, opengl_enabled);
#elif defined(CONFIG_COCOA)
if (sdl || !vnc_display)
cocoa_display_init(ds, full_screen);
}
}
+ for (i = 0; i < nb_pci_emulation; i++) {
+ if(pci_emulation_add(pci_emulation_config_text[i]) < 0) {
+ fprintf(stderr, "Warning: could not add PCI device %s\n",
+ pci_emulation_config_text[i]);
+ }
+ }
+
+ if (strlen(direct_pci_str) > 0)
+ direct_pci = direct_pci_str;
+
for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
const char *devname = virtio_consoles[i];
if (virtcon_hds[i] && devname) {
return 0;
}
+
+static int unix_start_timer(struct qemu_alarm_timer *t) { return 0; }
+static void unix_stop_timer(struct qemu_alarm_timer *t) { }
}
#ifdef CONFIG_VNC_TLS
-ssize_t vnc_tls_push(gnutls_transport_ptr_t transport,
+static ssize_t vnc_tls_push(gnutls_transport_ptr_t transport,
const void *data,
size_t len) {
struct VncState *vs = (struct VncState *)transport;
}
-ssize_t vnc_tls_pull(gnutls_transport_ptr_t transport,
+static ssize_t vnc_tls_pull(gnutls_transport_ptr_t transport,
void *data,
size_t len) {
struct VncState *vs = (struct VncState *)transport;
}
}
-extern int parse_host_port(struct sockaddr_in *saddr, const char *str);
-
void vnc_display_init(DisplayState *ds)
{
VncState *vs;
#endif
}
-int parse_host_port(struct sockaddr_in *saddr, const char *str);
-
-
-
int vnc_display_password(DisplayState *ds, const char *password)
{
VncState *vs = ds ? (VncState *)ds->opaque : vnc_state;
return ntohs(iaddr.sin_port);
}
-
-#ifndef CONFIG_STUBDOM
-int vnc_start_viewer(int port)
-{
- int pid, i, open_max;
- char s[16];
-
- sprintf(s, ":%d", port);
-
- switch (pid = fork()) {
- case -1:
- fprintf(stderr, "vncviewer failed fork\n");
- exit(1);
-
- case 0: /* child */
- open_max = sysconf(_SC_OPEN_MAX);
- for (i = 0; i < open_max; i++)
- if (i != STDIN_FILENO &&
- i != STDOUT_FILENO &&
- i != STDERR_FILENO)
- close(i);
- execlp("vncviewer", "vncviewer", s, NULL);
- fprintf(stderr, "vncviewer execlp failed\n");
- exit(1);
-
- default:
- return pid;
- }
-}
-#endif
-
#define NO_BLUETOOTH_PASSTHROUGH 1
#endif
+#define CONFIG_DM
+
extern char domain_name[64];
extern int domid, domid_backend;
#define DEFAULT_NETWORK_SCRIPT "/etc/xen/qemu-ifup"
#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/xen/qemu-ifdown"
-void xenstore_parse_domain_config(int domid);
-void xenstore_read_vncpasswd(int domid, char *pwbuf, size_t pwbuflen);
#ifdef CONFIG_STUBDOM
extern struct BlockDriver bdrv_vbd;
#endif
CFLAGS += -DUSE_SSE2=1 -msse2
endif
-QEMU_PROG=qemu-dm
+override QEMU_PROG=qemu-dm
CFLAGS += -Wno-unused -Wno-declaration-after-statement
endif
BAD_OBJS += gdbstub.o acpi.o apic.o
-BAD_OBJS += vmmouse.o vmport.o tcg* helper.o
+BAD_OBJS += vmmouse.o vmport.o tcg* helper.o vmware_vga.o virtio-balloon.o
OBJS := $(filter-out $(BAD_OBJS), $(OBJS))
/* There is no need for multiple-inclusion protection since
* there is only one place where this file is included. */
-#include "qemu-xen.h"
/* Max number of PCI emulation */
}
struct qemu_alarm_timer;
-static int unix_start_timer(struct qemu_alarm_timer *t) { return 0; }
-static void unix_stop_timer(struct qemu_alarm_timer *t) { }
#ifdef CONFIG_STUBDOM
#include <netfront.h>
projects / qemu-xen-4.1-testing.git / commitdiff